Version updated

* RadzenBlazorDemos.Tools added

* GenerateLlmsTxt Condition update to Release

* GenerateLlmsTxt updated again

* code fixed

* content generation cleaned

* razor/html tags removed from example descriptions and the code is now inside codeblock

* more fixes

.github/ISSUE_TEMPLATE/bug_report.md

@@ -11,7 +11,7 @@ assignees: ''
 
 IMPORTANT: Read this first!!!
 
-1. If you own a Radzen Professional or Еnterprise subscription you can report your issue or ask us a question via email at info@radzen.com. Radzen staff will reply within 24 hours (Professional) or 16 hours (Enterprise)
+1. If you own a Radzen Blazor subscription you can report your issue or ask us a question via email at info@radzen.com. Radzen staff will reply within 24 hours (Pro) or 16 hours (Team)
 2. The Radzen staff guarantees a response to issues in this repo only to paid subscribers. 
 3. If you have a HOW TO question start a new forum thread in the Radzen Community forum: https://forum.radzen.com. Radzen staff will close issues that are HOWTO questions.
 4. Please adhere to the issue template. Specify all the steps required to reproduce the issue or link a project which reproduces it easily (without requiring extra steps such as restoring a database).

.github/ISSUE_TEMPLATE/config.yml

@@ -5,4 +5,4 @@ contact_links:
     about: Please ask and answer questions here.
   - name: Radzen Commercial Support 
     url: info@radzen.com
-    about: Radzen Professional or Enterprise subscribers can get dedicated support over email.
+    about: Radzen Blazor subscribers can get dedicated support over email.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -11,7 +11,7 @@ assignees: ''
 
 IMPORTANT: Read this first!!!
 
-1. If you own a Radzen Professional or Еnterprise subscription you can request your feature via email at info@radzen.com. Radzen staff will reply within 24 hours (Professional) or 16 hours (Enterprise)
+1. If you own a Radzen Blazor subscription you can request your feature via email at info@radzen.com. Radzen staff will reply within 24 hours (Pro) or 16 hours (Team)
 2. The Radzen staff guarantees a response to issues in this repo only to paid subscribers. 
 3. If you have a HOW TO question start a new forum thread in the Radzen Community forum: https://forum.radzen.com. Radzen staff will close issues that are HOWTO questions.
 4. Please adhere to the issue template. 

.github/workflows/ci.yml

@@ -20,7 +20,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 9.0.x
+        dotnet-version: 10.0.x
     
     - name: Build
       run: dotnet build Radzen.Blazor/Radzen.Blazor.csproj

.gitignore

@@ -342,3 +342,9 @@ Radzen.DocFX/api/*.yml
 !Radzen.DocFX/api/index.md
 Radzen.DocFX/api/.manifest
 Radzen.Blazor.min.js
+/.claude
+/SANKEY_PATTERN_COMPARISON.md
+*.md
+/.gitignore
+/.gitignore
+RadzenBlazorDemos/wwwroot/demos

CONTRIBUTING.md

@@ -19,7 +19,7 @@ You can ask your question here. Please use the [Radzen.Blazor Components](https:
 
 ### Dedicated technical support
 
-Radzen staff provides technical support with guaranteed response time to Radzen Professional and Enterprise subscribers. The pricing options are available [here](https://www.radzen.com/blazor-studio/pricing/).
+Radzen staff provides technical support with guaranteed response time to Radzen Professional and Enterprise subscribers. The pricing options are available [here](https://www.radzen.com/pricing).
 
 ## How Can I Contribute?
 

Dockerfile

@@ -1,31 +1,23 @@
-# syntax=docker/dockerfile:1
-FROM mono:latest
-
-ENV DOCFX_VER 2.58.4
-
-RUN apt-get update && apt-get install unzip wget git -y && wget -q -P /tmp https://github.com/dotnet/docfx/releases/download/v${DOCFX_VER}/docfx.zip && \
-    mkdir -p /opt/docfx && \
-    unzip /tmp/docfx.zip -d /opt/docfx && \
-    echo '#!/bin/bash\nmono /opt/docfx/docfx.exe $@' > /usr/bin/docfx && \
-    chmod +x /usr/bin/docfx && \
-    rm -rf /tmp/*
+FROM mcr.microsoft.com/dotnet/sdk:10.0
 
 COPY Radzen.Blazor /app/Radzen.Blazor
-COPY Radzen.DocFX /app/DocFX
+COPY Radzen.DocFX /app/Radzen.DocFX
 COPY RadzenBlazorDemos /app/RadzenBlazorDemos
 COPY RadzenBlazorDemos.Host /app/RadzenBlazorDemos.Host
+
 WORKDIR /app
-RUN docfx DocFX/docfx.json
 
-FROM mcr.microsoft.com/dotnet/sdk:9.0
-
-COPY --from=0 /app/RadzenBlazorDemos.Host /app/RadzenBlazorDemos.Host
-COPY --from=0 /app/RadzenBlazorDemos /app/RadzenBlazorDemos
+RUN dotnet tool install -g docfx
+ENV PATH="$PATH:/root/.dotnet/tools"
+RUN wget https://dot.net/v1/dotnet-install.sh \
+    && bash dotnet-install.sh --channel 8.0 --runtime dotnet --install-dir /usr/share/dotnet
+RUN dotnet build -c Release Radzen.Blazor/Radzen.Blazor.csproj -f net8.0
+RUN docfx Radzen.DocFX/docfx.json
 
 WORKDIR /app/RadzenBlazorDemos.Host
 RUN dotnet publish -c Release -o out
 
-ENV ASPNETCORE_URLS http://*:5000
+ENV ASPNETCORE_URLS=http://*:5000
 WORKDIR /app/RadzenBlazorDemos.Host/out
 
 ENTRYPOINT ["dotnet", "RadzenBlazorDemos.Host.dll"]

README.md

@@ -3,7 +3,7 @@
 Radzen Blazor Components
 ========================
 
-A set of **90+ free and open source** native Blazor UI controls.
+The most sophisticated free UI component library for Blazor, featuring **100+ native components**.
 
 See Online Demos or Read the Docs
 
@@ -15,7 +15,7 @@ See Online Demos or Read the Docs
 
 Radzen Blazor Components are open source and free for commercial use. You can install them from [NuGet](https://www.nuget.org/packages/Radzen.Blazor) or build your own copy from source.
 
-Paid support is available as part of the [Radzen Professional subscription](https://www.radzen.com/blazor-studio/pricing/).
+Paid support is available as part of the [Radzen Blazor subscription](https://www.radzen.com/pricing).
 
 ### :computer: Native
 
@@ -38,9 +38,9 @@ Everybody is welcome to visit the [Radzen Community forum](https://forum.radzen.
 
 The Radzen team monitors the forum threads, but does not guarantee a response to every question. For guaranteed responses you may consider the dedicated support option.
 
-Dedicated support for the Radzen Blazor Components is available as part of the [Radzen Professional subscription](https://www.radzen.com/blazor-studio/pricing/).
+Dedicated support for the Radzen Blazor Components is available as part of the [Radzen Blazor subscription](https://www.radzen.com/pricing).
 
-Our flagship product [Radzen Blazor Studio](https://www.radzen.com/blazor-studio/) provides tons of productivity features for Blazor developers:
+Our flagship product [Radzen Blazor Studio](https://www.radzen.com/blazor-studio) provides tons of productivity features for Blazor developers:
 - An industry-leading WYSIWYG Blazor design time canvas
 - Scaffolding a complete CRUD applications from a database
 - Built-in security - authentication and authorization
@@ -50,7 +50,7 @@ Our flagship product [Radzen Blazor Studio](https://www.radzen.com/blazor-studio
 
 ## Get started with Radzen Blazor Components
 
-Check the [getting started](https://blazor.radzen.com/getting-started) instructions to start making awesome Blazor applications.
+Check the [getting started](https://blazor.radzen.com/get-started) instructions to start making awesome Blazor applications.
 
 ## Run demos locally
 

Radzen.Blazor.Tests/AIChatTests.cs

@@ -0,0 +1,171 @@
+using Bunit;
+using Microsoft.Extensions.DependencyInjection;
+using Radzen;
+using System;
+using System.Net.Http;
+using Microsoft.Extensions.Options;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class AIChatTests
+    {
+        private void RegisterChatService(TestContext ctx)
+        {
+            // Register a dummy HttpClient and default options for AIChatService
+            ctx.Services.AddSingleton(new HttpClient());
+            ctx.Services.AddScoped<IAIChatService, AIChatService>();
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldRenderWithDefaultProperties()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            Assert.Contains("Type your message...", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldRenderWithCustomTitle()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.Title, "Custom Chat"));
+            Assert.Contains("Custom Chat", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldRenderWithCustomPlaceholder()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.Placeholder, "Enter your message here..."));
+            Assert.Contains("Enter your message here...", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldRenderWithCustomEmptyMessage()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.EmptyMessage, "No messages yet"));
+            Assert.Contains("No messages yet", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldShowClearButtonByDefault()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            Assert.Contains("rz-chat-header-clear", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldHideClearButtonWhenShowClearButtonIsFalse()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.ShowClearButton, false));
+            Assert.DoesNotContain("clear_all", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldBeDisabledWhenDisabledIsTrue()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.Disabled, true));
+            Assert.Contains("disabled", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldBeReadOnlyWhenReadOnlyIsTrue()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.ReadOnly, true));
+            Assert.Contains("readonly", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldHaveCorrectCssClass()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            Assert.Contains("rz-chat", component.Markup);
+        }
+
+        [Fact]
+        public void ChatMessage_ShouldHaveCorrectProperties()
+        {
+            // Arrange
+            var message = new ChatMessage
+            {
+                Content = "Test message",
+                IsUser = true,
+                Timestamp = DateTime.Now
+            };
+            // Assert
+            Assert.NotEmpty(message.Id);
+            Assert.Equal("Test message", message.Content);
+            Assert.True(message.IsUser);
+            Assert.False(message.IsStreaming);
+        }
+
+        [Fact]
+        public void RadzenAIChat_AddMessage_ShouldAddMessageToList()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            // Act
+            component.Instance.AddMessage("Test message", true);
+            // Assert
+            var messages = component.Instance.GetMessages();
+            Assert.Single(messages);
+            Assert.Equal("Test message", messages[0].Content);
+            Assert.True(messages[0].IsUser);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ClearChat_ShouldRemoveAllMessages()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            component.Instance.AddMessage("Test message 1", true);
+            component.Instance.AddMessage("Test message 2", false);
+            // Act
+            component.InvokeAsync(async () => await component.Instance.ClearChat()).Wait();
+            // Assert
+            Assert.Empty(component.Instance.GetMessages());
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldLimitMessagesToMaxMessages()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters.Add(p => p.MaxMessages, 3));
+            component.Instance.AddMessage("Message 1", true);
+            component.Instance.AddMessage("Message 2", false);
+            component.Instance.AddMessage("Message 3", true);
+            component.Instance.AddMessage("Message 4", false);
+            // Assert
+            var messages = component.Instance.GetMessages();
+            Assert.Equal(3, messages.Count);
+            Assert.Equal("Message 2", messages[0].Content);
+            Assert.Equal("Message 3", messages[1].Content);
+            Assert.Equal("Message 4", messages[2].Content);
+        }
+    }
+} 

Radzen.Blazor.Tests/AccordionTests.cs

@@ -0,0 +1,195 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class AccordionTests
+    {
+        [Fact]
+        public void Accordion_Renders_CssClasses()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>();
+
+            Assert.Contains(@"rz-accordion", component.Markup);
+        }
+
+        [Fact]
+        public void Accordion_Renders_AccordionItems()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Test Item");
+                    builder.AddAttribute(2, "ChildContent", (RenderFragment)(contentBuilder =>
+                    {
+                        contentBuilder.AddContent(0, "Item Content");
+                    }));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("Test Item", component.Markup);
+            Assert.Contains("Item Content", component.Markup);
+        }
+
+        [Fact]
+        public void Accordion_Renders_ItemWithIcon()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Orders");
+                    builder.AddAttribute(2, "Icon", "account_balance_wallet");
+                    builder.AddAttribute(3, "ChildContent", (RenderFragment)(contentBuilder =>
+                    {
+                        contentBuilder.AddContent(0, "Order Details");
+                    }));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("account_balance_wallet", component.Markup);
+            Assert.Contains("Orders", component.Markup);
+        }
+
+        [Fact]
+        public void Accordion_SingleExpand_OnlyOneItemExpanded()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, false); // Single expand mode
+                parameters.Add(p => p.Items, builder =>
+                {
+                    // Add first item
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Item 1");
+                    builder.AddAttribute(2, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content 1")));
+                    builder.CloseComponent();
+
+                    // Add second item
+                    builder.OpenComponent<RadzenAccordionItem>(1);
+                    builder.AddAttribute(1, "Text", "Item 2");
+                    builder.AddAttribute(2, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content 2")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.False(component.Instance.Multiple);
+        }
+
+        [Fact]
+        public void Accordion_MultipleExpand_AllowsMultipleItemsExpanded()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+            });
+
+            Assert.True(component.Instance.Multiple);
+        }
+
+        [Fact]
+        public void Accordion_Raises_ExpandEvent()
+        {
+            using var ctx = new TestContext();
+            
+            var expandRaised = false;
+            int expandedIndex = -1;
+
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Expand, EventCallback.Factory.Create<int>(this, (index) =>
+                {
+                    expandRaised = true;
+                    expandedIndex = index;
+                }));
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Test Item");
+                    builder.AddAttribute(2, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content")));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Find and click the accordion header link to expand
+            var header = component.Find(".rz-accordion-header a");
+            header.Click();
+
+            Assert.True(expandRaised);
+            Assert.Equal(0, expandedIndex);
+        }
+
+        [Fact]
+        public void Accordion_Raises_CollapseEvent()
+        {
+            using var ctx = new TestContext();
+            
+            var collapseRaised = false;
+            int collapsedIndex = -1;
+
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Collapse, EventCallback.Factory.Create<int>(this, (index) =>
+                {
+                    collapseRaised = true;
+                    collapsedIndex = index;
+                }));
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Test Item");
+                    builder.AddAttribute(2, "Selected", true); // Start expanded
+                    builder.AddAttribute(3, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content")));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Find and click the accordion header link to collapse
+            var header = component.Find(".rz-accordion-header a");
+            header.Click();
+
+            Assert.True(collapseRaised);
+            Assert.Equal(0, collapsedIndex);
+        }
+
+        [Fact]
+        public void Accordion_DisabledItem_CannotExpand()
+        {
+            using var ctx = new TestContext();
+            
+            var expandRaised = false;
+
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Expand, EventCallback.Factory.Create<int>(this, (_) => expandRaised = true));
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Disabled Item");
+                    builder.AddAttribute(2, "Disabled", true);
+                    builder.AddAttribute(3, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content")));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Try to click the disabled item
+            var header = component.Find(".rz-accordion-header a");
+            header.Click();
+
+            // Event should not be raised for disabled item
+            Assert.False(expandRaised);
+        }
+    }
+}
+

Radzen.Blazor.Tests/AlertTests.cs

@@ -0,0 +1,195 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class AlertTests
+    {
+        [Fact]
+        public void Alert_Renders_CssClasses()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            Assert.Contains(@"rz-alert", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_AlertStyle()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlertStyle, AlertStyle.Danger));
+            Assert.Contains("rz-danger", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlertStyle, AlertStyle.Success));
+            Assert.Contains("rz-success", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlertStyle, AlertStyle.Warning));
+            Assert.Contains("rz-warning", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlertStyle, AlertStyle.Info));
+            Assert.Contains("rz-info", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_Shade()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            component.SetParametersAndRender(parameters => parameters
+                .Add(p => p.AlertStyle, AlertStyle.Primary)
+                .Add(p => p.Shade, Shade.Lighter));
+
+            Assert.Contains("rz-shade-lighter", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters
+                .Add(p => p.AlertStyle, AlertStyle.Primary)
+                .Add(p => p.Shade, Shade.Darker));
+
+            Assert.Contains("rz-shade-darker", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_Variant()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Outlined));
+            Assert.Contains("rz-variant-outlined", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Flat));
+            Assert.Contains("rz-variant-flat", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_Title()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            var title = "Alert Title";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Title, title));
+
+            Assert.Contains(title, component.Markup);
+            Assert.Contains("rz-alert-title", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_Text()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            var text = "This is an alert message";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
+
+            Assert.Contains(text, component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>(parameters =>
+            {
+                parameters.AddChildContent("Custom alert content");
+            });
+
+            Assert.Contains("Custom alert content", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_ShowIcon_DisplaysIcon()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            // Default should show icon
+            Assert.Contains("rz-alert-icon", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ShowIcon, false));
+            Assert.DoesNotContain("rz-alert-icon", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_AllowClose_DisplaysCloseButton()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            // Default AllowClose is true - should contain a button with close icon
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AllowClose, true));
+            Assert.Contains("close", component.Markup);
+            Assert.Contains("rz-button", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AllowClose, false));
+            // When AllowClose is false, should not have close button
+            var buttonCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rz-button").Count;
+            Assert.Equal(0, buttonCount);
+        }
+
+        [Fact]
+        public void Alert_CloseButton_RaisesCloseEvent()
+        {
+            using var ctx = new TestContext();
+            
+            var closeRaised = false;
+
+            var component = ctx.RenderComponent<RadzenAlert>(parameters =>
+            {
+                parameters.Add(p => p.AllowClose, true);
+                parameters.Add(p => p.Close, () => closeRaised = true);
+            });
+
+            var closeButton = component.Find("button.rz-button");
+            closeButton.Click();
+
+            Assert.True(closeRaised);
+        }
+
+        [Fact]
+        public void Alert_Visible_ControlsDisplay()
+        {
+            using var ctx = new TestContext();
+            
+            var component = ctx.RenderComponent<RadzenAlert>(parameters =>
+            {
+                parameters.Add(p => p.Visible, true);
+                parameters.Add(p => p.Text, "Visible Alert");
+            });
+
+            Assert.Contains("Visible Alert", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Visible, false));
+
+            // When not visible, component should not render
+            Assert.DoesNotContain("Visible Alert", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_CloseButton_SetsVisibleToFalse()
+        {
+            using var ctx = new TestContext();
+            
+            var visibleValue = true;
+
+            var component = ctx.RenderComponent<RadzenAlert>(parameters =>
+            {
+                parameters.Add(p => p.Visible, visibleValue);
+                parameters.Add(p => p.AllowClose, true);
+                parameters.Add(p => p.VisibleChanged, (bool value) => visibleValue = value);
+            });
+
+            var closeButton = component.Find("button.rz-button");
+            closeButton.Click();
+
+            Assert.False(visibleValue);
+        }
+    }
+}
+
+

Radzen.Blazor.Tests/AutoCompleteTests.cs

@@ -1,9 +1,74 @@
-using Xunit;
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
 
 namespace Radzen.Blazor.Tests
 {
 	public class AutoCompleteTests
 	{
+        [Fact]
+        public void AutoComplete_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenAutoComplete>();
+
+            Assert.Contains(@"rz-autocomplete", component.Markup);
+        }
+
+        [Fact]
+        public void AutoComplete_Renders_InputElement()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenAutoComplete>();
+
+            Assert.Contains("type=\"text\"", component.Markup);
+            Assert.Contains("rz-inputtext", component.Markup);
+        }
+
+        [Fact]
+        public void AutoComplete_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenAutoComplete>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void AutoComplete_Renders_Placeholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenAutoComplete>(parameters =>
+            {
+                parameters.Add(p => p.Placeholder, "Type to search...");
+            });
+
+            Assert.Contains("placeholder=\"Type to search...\"", component.Markup);
+        }
+
+        [Fact]
+        public void AutoComplete_Renders_WithData()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Apple", "Banana", "Cherry" };
+
+            var component = ctx.RenderComponent<RadzenAutoComplete>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-autocomplete-panel", component.Markup);
+        }
+
         [Fact]
         public void AutoComplete_Enum_Converts_To_Attr_Value()
         {

Radzen.Blazor.Tests/CardTests.cs

@@ -0,0 +1,46 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class CardTests
+    {
+        [Fact]
+        public void Card_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCard>();
+
+            Assert.Contains(@"rz-card", component.Markup);
+        }
+
+        [Fact]
+        public void Card_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCard>(parameters =>
+            {
+                parameters.AddChildContent("<div>Card Content</div>");
+            });
+
+            Assert.Contains("Card Content", component.Markup);
+        }
+
+        [Fact]
+        public void Card_Renders_Variant()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCard>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Outlined));
+            Assert.Contains("rz-variant-outlined", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Filled));
+            Assert.Contains("rz-variant-filled", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Flat));
+            Assert.Contains("rz-variant-flat", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/CarouselTests.cs

@@ -0,0 +1,173 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class CarouselTests
+    {
+        [Fact]
+        public void Carousel_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>();
+
+            Assert.Contains(@"rz-carousel", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_AllowPaging_True()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide 1")));
+                    builder.CloseComponent();
+                    
+                    builder.OpenComponent<RadzenCarouselItem>(2);
+                    builder.AddAttribute(3, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide 2")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("rz-carousel-pager-button", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_AllowPaging_False()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, false);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide 1")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.DoesNotContain("rz-carousel-pager-button", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_AllowNavigation_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.AllowNavigation, true);
+            });
+
+            Assert.Contains("rz-carousel-prev", component.Markup);
+            Assert.Contains("rz-carousel-next", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_AllowNavigation_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.AllowNavigation, false);
+            });
+
+            Assert.DoesNotContain("rz-carousel-prev", component.Markup);
+            Assert.DoesNotContain("rz-carousel-next", component.Markup);
+            Assert.Contains("rz-carousel-no-navigation", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerPosition_Top()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerPosition, PagerPosition.Top);
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("rz-carousel-pager-top", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerPosition_Bottom()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerPosition, PagerPosition.Bottom);
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("rz-carousel-pager-bottom", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerPosition_TopAndBottom()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerPosition, PagerPosition.TopAndBottom);
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("rz-carousel-pager-top", component.Markup);
+            Assert.Contains("rz-carousel-pager-bottom", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerOverlay_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerOverlay, true);
+            });
+
+            Assert.Contains("rz-carousel-pager-overlay", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerOverlay_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerOverlay, false);
+            });
+
+            Assert.DoesNotContain("rz-carousel-pager-overlay", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/ChatTests.cs

@@ -0,0 +1,369 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
+using Radzen.Blazor;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ChatTests
+    {
+        [Fact]
+        public void RadzenChat_ShouldRenderWithTitle()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+            );
+
+            Assert.Contains("Test Chat", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowEmptyMessageWhenNoMessages()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.EmptyMessage, "No messages yet!")
+            );
+
+            Assert.Contains("No messages yet!", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldDisplayMessages()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Hello", UserId = "user1", Timestamp = DateTime.Now },
+                new ChatMessage { Content = "Hi there!", UserId = "user2", Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            Assert.Contains("Hello", component.Markup);
+            Assert.Contains("Hi there!", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowUsersInHeader()
+        {
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowUsers, true)
+            );
+
+            Assert.Contains("John", component.Markup);
+            Assert.Contains("Jane", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowUserNamesAboveMessages()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Hello", UserId = "user2", Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+                .Add(p => p.ShowUserNames, true)
+            );
+
+            Assert.Contains("Jane", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowClearButtonWhenEnabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowClearButton, true)
+            );
+
+            var clearButton = component.Find(".rz-chat-header-clear");
+            Assert.NotNull(clearButton);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldNotShowClearButtonWhenDisabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowClearButton, false)
+            );
+
+            var clearButton = component.FindAll(".rz-chat-header-clear");
+            Assert.Empty(clearButton);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldLimitVisibleUsers()
+        {
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" },
+                new ChatUser { Id = "user3", Name = "Bob" },
+                new ChatUser { Id = "user4", Name = "Alice" },
+                new ChatUser { Id = "user5", Name = "Charlie" },
+                new ChatUser { Id = "user6", Name = "David" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowUsers, true)
+                .Add(p => p.MaxVisibleUsers, 3)
+            );
+
+            // Should show "+3" for the remaining users
+            Assert.Contains("+3", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowUserMessagesOnRight()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "My message", UserId = "user1", Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            var userMessage = component.Find(".rz-chat-message-user");
+            Assert.NotNull(userMessage);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowUserMessagesOnLeft()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Other message", UserId = "user2", Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            var participantMessage = component.Find(".rz-chat-message-participant");
+            Assert.NotNull(participantMessage);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowAvatarInitials()
+        {
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John Doe" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowUsers, true)
+            );
+
+            Assert.Contains("JD", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowAvatarImageWhenProvided()
+        {
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John", AvatarUrl = "https://example.com/avatar.jpg" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowUsers, true)
+            );
+
+            var avatarImage = component.Find(".rz-chat-participant-image");
+            Assert.NotNull(avatarImage);
+            Assert.Equal("https://example.com/avatar.jpg", avatarImage.GetAttribute("src"));
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldBeDisabledWhenDisabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.Disabled, true)
+            );
+
+            var textarea = component.Find(".rz-chat-textarea");
+            Assert.True(textarea.HasAttribute("disabled"));
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldBeReadOnlyWhenReadOnly()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ReadOnly, true)
+            );
+
+            var textarea = component.Find(".rz-chat-textarea");
+            Assert.True(textarea.HasAttribute("readonly"));
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowCustomPlaceholder()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.Placeholder, "Custom placeholder")
+            );
+
+            var textarea = component.Find(".rz-chat-textarea");
+            Assert.Equal("Custom placeholder", textarea.GetAttribute("placeholder"));
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowStreamingIndicator()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Streaming message", UserId = "user1", IsStreaming = true, Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            var streamingIcon = component.Find(".rz-chat-message-streaming-icon");
+            Assert.NotNull(streamingIcon);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowMessageTimestamps()
+        {
+            var timestamp = DateTime.Now.AddHours(-1);
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Test message", UserId = "user1", Timestamp = timestamp }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            Assert.Contains(timestamp.ToString("HH:mm"), component.Markup);
+        }
+    }
+}

Radzen.Blazor.Tests/CheckBoxListTests.cs

@@ -0,0 +1,168 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+
+namespace Radzen.Blazor.Tests
+{
+    public class CheckBoxListTests
+    {
+        class Item
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+            public bool Disabled { get; set; }
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>();
+
+            Assert.Contains(@"rz-checkbox-list", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_WithData()
+        {
+            using var ctx = new TestContext();
+            var data = new List<string> { "Option 1", "Option 2", "Option 3" };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("Option 1", component.Markup);
+            Assert.Contains("Option 2", component.Markup);
+            Assert.Contains("Option 3", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_WithCustomTextValueProperties()
+        {
+            using var ctx = new TestContext();
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "First" },
+                new Item { Id = 2, Name = "Second" }
+            };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "Name");
+                parameters.Add(p => p.ValueProperty, "Id");
+            });
+
+            Assert.Contains("First", component.Markup);
+            Assert.Contains("Second", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_Orientation_Horizontal()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Horizontal);
+            });
+
+            Assert.Contains("rz-flex-row", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_Orientation_Vertical()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Vertical);
+            });
+
+            Assert.Contains("rz-flex-column", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_AllowSelectAll()
+        {
+            using var ctx = new TestContext();
+            var data = new List<string> { "Option 1", "Option 2" };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowSelectAll, true);
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-multiselect-header", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_SelectAllText()
+        {
+            using var ctx = new TestContext();
+            var data = new List<string> { "Option 1", "Option 2" };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowSelectAll, true);
+                parameters.Add(p => p.SelectAllText, "Select All Options");
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("Select All Options", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_CheckboxInputs()
+        {
+            using var ctx = new TestContext();
+            var data = new List<string> { "Option 1", "Option 2" };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("type=\"checkbox\"", component.Markup);
+            Assert.Contains("rz-chkbox", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_DisabledItems()
+        {
+            using var ctx = new TestContext();
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "Enabled", Disabled = false },
+                new Item { Id = 2, Name = "Disabled", Disabled = true }
+            };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "Name");
+                parameters.Add(p => p.ValueProperty, "Id");
+                parameters.Add(p => p.DisabledProperty, "Disabled");
+            });
+
+            Assert.Contains("Enabled", component.Markup);
+            Assert.Contains("Disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/ColumnTests.cs

@@ -0,0 +1,74 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ColumnTests
+    {
+        [Fact]
+        public void Column_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            Assert.Contains(@"rz-col", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>(parameters =>
+            {
+                parameters.AddChildContent("<div>Column Content</div>");
+            });
+
+            Assert.Contains("Column Content", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_SizeParameter()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, 6));
+
+            Assert.Contains("rz-col-6", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_SizeMD()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.SizeMD, 4));
+
+            Assert.Contains("rz-col-md-4", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_SizeSM()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.SizeSM, 12));
+
+            Assert.Contains("rz-col-sm-12", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_Offset()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Offset, 2));
+
+            Assert.Contains("rz-offset-2", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/DatePickerTests.cs

@@ -732,5 +732,130 @@ namespace Radzen.Blazor.Tests
             var weekNumberHeader = component.Find(".rz-calendar-view th.rz-datepicker-week-number");
             Assert.Contains("Wk", weekNumberHeader.InnerHtml);
         }
+
+        [Fact]
+        public void DatePicker_Multiple_Selects_IEnumerableDateTime()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            IEnumerable<DateTime> emitted = null;
+            var initial = new DateTime(2024, 1, 1);
+
+            var component = ctx.RenderComponent<RadzenDatePicker<IEnumerable<DateTime>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.ValueChanged, args => { emitted = args; });
+            });
+
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "10").ParentElement.Click());
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "12").ParentElement.Click());
+
+            Assert.NotNull(emitted);
+            var list = emitted.ToList();
+            Assert.Equal(2, list.Count);
+            Assert.Contains(new DateTime(2024, 1, 10), list.Select(d => d.Date));
+            Assert.Contains(new DateTime(2024, 1, 12), list.Select(d => d.Date));
+        }
+
+        [Fact]
+        public void DatePicker_Multiple_Selects_IEnumerableNullableDateTime()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            IEnumerable<DateTime?> emitted = null;
+            var initial = new DateTime(2024, 2, 1);
+
+            var component = ctx.RenderComponent<RadzenDatePicker<IEnumerable<DateTime?>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.ValueChanged, args => { emitted = args; });
+            });
+
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "3").ParentElement.Click());
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "14").ParentElement.Click());
+
+            Assert.NotNull(emitted);
+            var list = emitted.ToList();
+            Assert.Equal(2, list.Count);
+            Assert.Contains(new DateTime(2024, 2, 3), list.Select(d => d.Value.Date));
+            Assert.Contains(new DateTime(2024, 2, 14), list.Select(d => d.Value.Date));
+        }
+
+        [Fact]
+        public void DatePicker_Multiple_Emits_IEnumerableDateTimeOffsetNullable_WithUtcKind()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            IEnumerable<DateTimeOffset?> emitted = null;
+            var initial = new DateTime(2024, 3, 1);
+
+            var component = ctx.RenderComponent<RadzenDatePicker<IEnumerable<DateTimeOffset?>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.Kind, DateTimeKind.Utc);
+                parameters.Add(p => p.ValueChanged, args => { emitted = args; });
+            });
+
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "5").ParentElement.Click());
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "20").ParentElement.Click());
+
+            Assert.NotNull(emitted);
+            var list = emitted.ToList();
+            Assert.Equal(2, list.Count);
+            Assert.All(list, dto => Assert.Equal(TimeSpan.Zero, dto.Value.Offset));
+        }
+
+        [Fact]
+        public void DatePicker_Multiple_Emits_IEnumerableDateOnlyAndTimeOnlyNullable()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            IEnumerable<DateOnly?> emittedDates = null;
+            IEnumerable<TimeOnly?> emittedTimes = null;
+            var initial = new DateTime(2024, 4, 1);
+
+            var compDates = ctx.RenderComponent<RadzenDatePicker<IEnumerable<DateOnly?>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.ValueChanged, args => { emittedDates = args; });
+            });
+
+            compDates.InvokeAsync(() => compDates.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "7").ParentElement.Click());
+            compDates.InvokeAsync(() => compDates.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "9").ParentElement.Click());
+
+            Assert.NotNull(emittedDates);
+            var dateList = emittedDates.ToList();
+            Assert.Equal(2, dateList.Count);
+            Assert.Contains(new DateOnly(2024, 4, 7), dateList.Select(d => d.Value));
+            Assert.Contains(new DateOnly(2024, 4, 9), dateList.Select(d => d.Value));
+
+            // TimeOnly? emission should produce midnight times for selected dates
+            var compTimes = ctx.RenderComponent<RadzenDatePicker<IEnumerable<TimeOnly?>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.ValueChanged, args => { emittedTimes = args; });
+            });
+
+            compTimes.InvokeAsync(() => compTimes.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "1").ParentElement.Click());
+            compTimes.InvokeAsync(() => compTimes.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "2").ParentElement.Click());
+
+            Assert.NotNull(emittedTimes);
+            var timeList = emittedTimes.ToList();
+            Assert.Equal(2, timeList.Count);
+            Assert.All(timeList, t => Assert.Equal(new TimeOnly(0, 0, 0), t.Value));
+        }
     }
 }

Radzen.Blazor.Tests/DialogServiceTests.cs

@@ -1,11 +1,15 @@
-using System;
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
 {
-	public class DialogServiceTests
+	public class DialogServiceTests : ComponentBase
 	{
 		public class OpenDialogTests
 		{
@@ -124,13 +128,81 @@ namespace Radzen.Blazor.Tests
                 var openTask = dialogService.OpenAsync("Dynamic Open", typeof(RadzenButton), []);
                 dialogService.Close();
                 await openTask;
-                
+
                 // Assert
                 Assert.Equal("Dynamic Open", resultingTitle);
                 Assert.Equal(typeof(RadzenButton), resultingType);
             }
 		}
 
+        public class OpenSideDialogTests
+        {
+            [Fact(DisplayName = "SideDialogOptions resizable option is retained after OpenSideDialog call")]
+            public void SideDialogOptions_Resizable_AreRetained_AfterOpenSideDialogCall()
+            {
+                // Arrange
+                var options = new SideDialogOptions { Resizable = true };
+                SideDialogOptions resultingOptions = null;
+                var dialogService = new DialogService(null, null);
+                dialogService.OnSideOpen += (_, _, sideOptions) => resultingOptions = sideOptions;
+
+                // Act
+                dialogService.OpenSide<DialogServiceTests>("Test", [], options);
+
+                // Assert
+                Assert.NotNull(resultingOptions);
+                Assert.Same(options, resultingOptions);
+                Assert.True(resultingOptions.Resizable);
+            }
+
+            [Fact(DisplayName = "Side dialog shows resize bar when Resizable is true")]
+            public void SideDialog_Resizable_ShowsResizeBar()
+            {
+                using var ctx = new TestContext();
+                ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+                ctx.Services.AddScoped<DialogService>();
+
+                // Render the dialog host
+                var cut = ctx.RenderComponent<RadzenDialog>();
+
+                // Open a side dialog with Resizable=true
+                var dialogService = ctx.Services.GetRequiredService<DialogService>();
+                cut.InvokeAsync(() => dialogService.OpenSide("Test", typeof(RadzenButton),
+                    new Dictionary<string, object>(), new SideDialogOptions { Resizable = true }));
+
+                // Assert: the resize bar element is present
+                cut.WaitForAssertion(() =>
+                {
+                    var markup = cut.Markup;
+                    Assert.Contains("rz-dialog-resize-bar", markup);
+                    // Optionally ensure the inner handle exists too
+                    Assert.Contains("rz-resize", markup);
+                });
+            }
+
+            [Fact(DisplayName = "Side dialog hides resize bar when Resizable is false")]
+            public void SideDialog_NonResizable_HidesResizeBar()
+            {
+                using var ctx = new TestContext();
+                ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+                ctx.Services.AddScoped<DialogService>();
+
+                // Render the dialog host
+                var cut = ctx.RenderComponent<RadzenDialog>();
+
+                // Open a side dialog with Resizable=false
+                var dialogService = ctx.Services.GetRequiredService<DialogService>();
+                cut.InvokeAsync(() => dialogService.OpenSide("Test", typeof(RadzenButton),
+                    new Dictionary<string, object>(), new SideDialogOptions()));
+
+                // Assert: the resize bar element is not present
+                cut.WaitForAssertion(() =>
+                {
+                    var markup = cut.Markup;
+                    Assert.DoesNotContain("rz-dialog-resize-bar", markup);
+                });
+            }
+        }
 		public class ConfirmTests
 		{
 			[Fact(DisplayName = "ConfirmOptions is null and default values are set correctly")]

Radzen.Blazor.Tests/DropDownDataGridTests.cs

@@ -0,0 +1,289 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Radzen.Blazor.Tests
+{
+    public class DropDownDataGridTests
+    {
+        class Customer
+        {
+            public int Id { get; set; }
+            public string CompanyName { get; set; }
+            public string ContactName { get; set; }
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>();
+
+            Assert.Contains(@"rz-dropdown", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_DropdownTrigger()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>();
+
+            Assert.Contains("rz-dropdown-trigger", component.Markup);
+            Assert.Contains("rzi-chevron-down", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_WithData()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2", "Item3" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-lookup-panel", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_WithCustomTextValueProperties()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Customer>
+            {
+                new Customer { Id = 1, CompanyName = "Acme Corp", ContactName = "John Doe" },
+                new Customer { Id = 2, CompanyName = "Tech Inc", ContactName = "Jane Smith" }
+            };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "CompanyName");
+                parameters.Add(p => p.ValueProperty, "Id");
+            });
+
+            Assert.Contains("rz-lookup-panel", component.Markup);
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_DataGrid()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            // DropDownDataGrid embeds a DataGrid
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_AllowFiltering()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-lookup-search", component.Markup);
+            Assert.Contains("rz-lookup-search-input", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_Placeholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>(parameters =>
+            {
+                parameters.Add(p => p.Placeholder, "Select an item");
+            });
+
+            Assert.Contains("Select an item", component.Markup);
+            Assert.Contains("rz-placeholder", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_AllowClear_WithValue()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowClear, true);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.Value, "Item1");
+            });
+
+            Assert.Contains("rz-dropdown-clear-icon", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_DoesNotRender_AllowClear_WhenNotAllowed()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowClear, false);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.Value, "Item1");
+            });
+
+            Assert.DoesNotContain("rz-dropdown-clear-icon", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_Multiple_Panel()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<IEnumerable<int>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+            });
+
+            Assert.Contains("rz-multiselect-panel", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_Multiple_WithChips()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2" };
+            var selectedItems = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<IEnumerable<string>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Chips, true);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.Value, selectedItems);
+            });
+
+            Assert.Contains("rz-dropdown-chips-wrapper", component.Markup);
+            Assert.Contains("rz-chip", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_AllowSorting()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Customer>
+            {
+                new Customer { Id = 1, CompanyName = "Acme" }
+            };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowSorting, true);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "CompanyName");
+            });
+
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_SearchTextPlaceholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.SearchTextPlaceholder, "Type to filter...");
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("placeholder=\"Type to filter...\"", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_EmptyText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, new List<string>());
+                parameters.Add(p => p.EmptyText, "No items found");
+            });
+
+            Assert.Contains("No items found", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_PageSize()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = Enumerable.Range(1, 20).Select(i => $"Item {i}").ToList();
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.PageSize, 10);
+            });
+
+            // DataGrid with paging should be present
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_AllowRowSelectOnRowClick()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowRowSelectOnRowClick, true);
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/DropDownTests.cs

@@ -1,10 +1,11 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
 using AngleSharp.Dom;
 using Bunit;
 using Microsoft.AspNetCore.Components;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -15,7 +16,7 @@ namespace Radzen.Blazor.Tests
         {
             public string Text { get; set; }
             public int Id { get; set; }
-            public bool Disabled { get; set; } = false;
+            public bool Disabled { get; set; }
         }
 
         private static IRenderedComponent<RadzenDropDown<T>> DropDown<T>(TestContext ctx, Action<ComponentParameterCollectionBuilder<RadzenDropDown<T>>> configure = null)
@@ -45,6 +46,7 @@ namespace Radzen.Blazor.Tests
             return component;
         }
 
+
         [Fact]
         public async Task Dropdown_SelectItem_Method_Should_Not_Throw()
         {
@@ -127,7 +129,7 @@ namespace Radzen.Blazor.Tests
 
             List<DataItem> boundCollection = [new() { Text = "Item 2" }];
 
-            var component = DropDown<string>(ctx, parameters =>
+            var component = DropDown<List<DataItem>>(ctx, parameters =>
             {
                 parameters.Add(p => p.ItemComparer, new DataItemComparer());
                 parameters.Add(p => p.Multiple, true);
@@ -307,7 +309,7 @@ namespace Radzen.Blazor.Tests
                 selectedValues.Add(data[1].Id);
             }
 
-            var component = ctx.RenderComponent<RadzenDropDown<DataItem>>(parameters => parameters
+            var component = ctx.RenderComponent<RadzenDropDown<List<int>>>(parameters => parameters
                .Add(p => p.Data, data)
                .Add(p => p.Value, selectedValues)
                .Add(p => p.Multiple, true)
@@ -326,6 +328,321 @@ namespace Radzen.Blazor.Tests
             Assert.Equal(expectedAriaCheckedValue, selectAllCheckBox.GetAttribute("aria-checked"));
         }
 
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_HashSet_ReferencesInstance()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalHashSet = new HashSet<int>();
+            var capturedValue = (HashSet<int>)null;
+
+            var component = DropDownWithReferenceCollection<HashSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalHashSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<HashSet<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item
+            items[0].Click();
+            component.Render();
+
+            // Verify the same HashSet instance is Referenced
+            Assert.Same(originalHashSet, capturedValue);
+            
+            // Verify the item was added correctly
+            Assert.Single(originalHashSet);
+            Assert.Contains(1, originalHashSet);
+        }
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_HashSet_MultipleSelections()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalHashSet = new HashSet<int> { 2 }; // Pre-populate with Item 2
+            var capturedValues = new List<HashSet<int>>();
+
+            var component = DropDownWithReferenceCollection<HashSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalHashSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<HashSet<int>>(this, value => capturedValues.Add(value)));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item (should add to existing collection)
+            items[0].Click();
+            component.Render();
+
+            // Verify the same HashSet instance is Referenced
+            Assert.Single(capturedValues);
+            Assert.Same(originalHashSet, capturedValues[0]);
+            
+            // Verify both items are now in the collection
+            Assert.Equal(2, originalHashSet.Count);
+            Assert.Contains(1, originalHashSet);
+            Assert.Contains(2, originalHashSet);
+
+            // Deselect second item (should remove from collection)
+            items = component.FindAll(".rz-multiselect-item"); // Re-find items after render
+            items[1].Click();
+            component.Render();
+
+            // Verify the same HashSet instance is still Referenced
+            Assert.Equal(2, capturedValues.Count);
+            Assert.Same(originalHashSet, capturedValues[1]);
+            
+            // Verify only first item remains
+            Assert.Single(originalHashSet);
+            Assert.Contains(1, originalHashSet);
+            Assert.DoesNotContain(2, originalHashSet);
+        }
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_SortedSet_ReferencesInstance()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalSortedSet = new SortedSet<int>();
+            var capturedValue = (SortedSet<int>)null;
+
+            var component = DropDownWithReferenceCollection<SortedSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalSortedSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<SortedSet<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select both items
+            items[0].Click();
+            component.Render();
+            items = component.FindAll(".rz-multiselect-item"); // Re-find items after first click
+            items[1].Click();
+            component.Render();
+
+            // Verify the same SortedSet instance is Referenced
+            Assert.Same(originalSortedSet, capturedValue);
+            
+            // Verify items are sorted correctly
+            Assert.Equal(2, originalSortedSet.Count);
+            var sortedItems = originalSortedSet.ToList();
+            Assert.Equal(1, sortedItems[0]);
+            Assert.Equal(2, sortedItems[1]);
+        }
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_CustomCollection_ReferencesInstance()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalCollection = new CustomCollection<int>();
+            var capturedValue = (CustomCollection<int>)null;
+
+            var component = DropDownWithReferenceCollection<CustomCollection<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalCollection);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<CustomCollection<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item
+            items[0].Click();
+            component.Render();
+
+            // Verify the same custom collection instance is Referenced
+            Assert.Same(originalCollection, capturedValue);
+            
+            // Verify the item was added correctly
+            Assert.Single(originalCollection);
+            Assert.Contains(1, originalCollection);
+        }
+
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_List_ReferencesInstance()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalList = new List<int>();
+            var capturedValue = (List<int>)null;
+
+            var component = DropDownWithReferenceCollection<List<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalList);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<List<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item
+            items[0].Click();
+            component.Render();
+
+            // For List<T>, it should now Reference the instance since we removed the IList exclusion
+            // Arrays are now excluded instead
+            Assert.Same(originalList, capturedValue);
+            
+            // And the content should be correct
+            Assert.Single(capturedValue);
+            Assert.Contains(1, capturedValue);
+        }
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_DisabledByDefault()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalList = new List<int>();
+            var capturedValue = (List<int>)null;
+
+            var component = DropDown<List<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalList);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<List<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item
+            items[0].Click();
+            component.Render();
+
+            // When ReferenceCollectionOnSelection is false (default), a new instance should be created
+            Assert.NotSame(originalList, capturedValue);
+            
+            // But the content should still be correct
+            Assert.Single(capturedValue);
+            Assert.Contains(1, capturedValue);
+        }
+
+        [Fact]
+        public void DropDown_Reset_PreservesCollectionInstanceButClears()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalHashSet = new HashSet<int> { 1, 2 }; // Pre-populate
+            var capturedValues = new List<HashSet<int>>();
+
+            var component = DropDownWithReferenceCollection<HashSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalHashSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<HashSet<int>>(this, value => capturedValues.Add(value)));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            // Verify initial state - collection should have 2 items
+            Assert.Equal(2, originalHashSet.Count);
+            Assert.Contains(1, originalHashSet);
+            Assert.Contains(2, originalHashSet);
+
+            // Call Reset (public method that calls ClearAll internally)
+            component.InvokeAsync(() => component.Instance.Reset());
+            component.Render();
+
+            // Verify the same HashSet instance is preserved
+            Assert.Single(capturedValues);
+            Assert.Same(originalHashSet, capturedValues[0]);
+            
+            // Verify the collection is now cleared
+            Assert.Empty(originalHashSet);
+        }
+
+        [Fact]
+        public void DropDown_SelectAll_PreservesCollectionInstanceAndPopulates()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalHashSet = new HashSet<int>(); // Start empty
+            var capturedValues = new List<HashSet<int>>();
+
+            var component = DropDownWithReferenceCollection<HashSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.AllowSelectAll, true);
+                parameters.Add(p => p.Value, originalHashSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<HashSet<int>>(this, value => capturedValues.Add(value)));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            // Verify initial state - collection should be empty
+            Assert.Empty(originalHashSet);
+
+            // Find and click the "Select All" checkbox
+            var selectAllCheckBox = component.Find(".rz-multiselect-header input[type='checkbox']");
+            selectAllCheckBox.Click();
+            component.Render();
+
+            // Verify the same HashSet instance is preserved
+            Assert.Single(capturedValues);
+            Assert.Same(originalHashSet, capturedValues[0]);
+            
+            // Verify the collection now contains both items
+            Assert.Equal(2, originalHashSet.Count);
+            Assert.Contains(1, originalHashSet);
+            Assert.Contains(2, originalHashSet);
+        }
+
+        class ReferenceCollectionDropDown<T> : Radzen.Blazor.RadzenDropDown<T>
+        {
+            protected override void OnInitialized()
+            {
+                PreserveCollectionOnSelection = true;
+                base.OnInitialized();
+            }
+        }
+
+        private static IRenderedComponent<ReferenceCollectionDropDown<T>> DropDownWithReferenceCollection<T>(TestContext ctx, Action<ComponentParameterCollectionBuilder<ReferenceCollectionDropDown<T>>> configure = null)
+        {
+            var data = new[] {
+                new DataItem { Text = "Item 1", Id = 1 },
+                new DataItem { Text = "Item 2", Id = 2 },
+            };
+
+            var component = ctx.RenderComponent<ReferenceCollectionDropDown<T>>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, nameof(DataItem.Text));
+
+                if (configure != null)
+                {
+                    configure.Invoke(parameters);
+                }
+                else
+                {
+                    parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+                }
+            });
+
+            return component;
+        }
+
         class DataItemComparer : IEqualityComparer<DataItem>, IEqualityComparer<object>
         {
             public bool Equals(DataItem x, DataItem y)
@@ -353,5 +670,74 @@ namespace Radzen.Blazor.Tests
 
             }
         }
+
+        class CustomCollection<T> : ICollection<T>
+        {
+            private readonly List<T> _items = new();
+
+            public int Count => _items.Count;
+            public bool IsReadOnly => false;
+
+            public void Add(T item) => _items.Add(item);
+            public void Clear() => _items.Clear();
+            public bool Contains(T item) => _items.Contains(item);
+            public void CopyTo(T[] array, int arrayIndex) => _items.CopyTo(array, arrayIndex);
+            public bool Remove(T item) => _items.Remove(item);
+            public IEnumerator<T> GetEnumerator() => _items.GetEnumerator();
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
+        [Fact]
+        public void DropDown_Renders_Placeholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = ctx.RenderComponent<RadzenDropDown<int>>(parameters =>
+            {
+                parameters.Add(p => p.Placeholder, "Select an option");
+            });
+
+            Assert.Contains("Select an option", component.Markup);
+            Assert.Contains("rz-placeholder", component.Markup);
+        }
+
+        [Fact]
+        public void DropDown_Renders_AllowClear_WithValue()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new[] { new DataItem { Text = "Item 1", Id = 1 } };
+
+            var component = ctx.RenderComponent<RadzenDropDown<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowClear, true);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, nameof(DataItem.Text));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+                parameters.Add(p => p.Value, 1);
+            });
+
+            Assert.Contains("rz-dropdown-clear-icon", component.Markup);
+        }
+
+        [Fact]
+        public void DropDown_DoesNotRender_AllowClear_WhenNotAllowed()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new[] { new DataItem { Text = "Item 1", Id = 1 } };
+
+            var component = ctx.RenderComponent<RadzenDropDown<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowClear, false);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, nameof(DataItem.Text));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+                parameters.Add(p => p.Value, 1);
+            });
+
+            Assert.DoesNotContain("rz-dropdown-clear-icon", component.Markup);
+        }
     }
 }

Radzen.Blazor.Tests/ExpressionSerializerTests.cs

@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Linq.Expressions;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    class TestEntity
+    {
+        public string Name { get; set; }
+        public int Age { get; set; }
+        public double Salary { get; set; }
+        public float Score { get; set; }
+        public decimal Balance { get; set; }
+        public short Level { get; set; }
+        public long Population { get; set; }
+        public Status AccountStatus { get; set; }
+        public DateTime CreatedAt { get; set; }
+        public DateTimeOffset LastUpdated { get; set; }
+        public Guid Id { get; set; }
+        public TimeOnly StartTime { get; set; }
+        public DateOnly BirthDate { get; set; }
+        public List<int> Scores { get; set; }
+        public List<string> Tags { get; set; }
+        public List<TestEntity> Children { get; set; }
+        public Address Address { get; set; }
+        public double[] Salaries { get; set; }
+        public float[] Heights { get; set; }
+        public decimal[] Balances { get; set; }
+        public short[] Levels { get; set; }
+        public long[] Populations { get; set; }
+        public string[] Names { get; set; }
+        public Guid[] Ids { get; set; }
+        public DateTime[] CreatedDates { get; set; }
+        public DateTimeOffset[] UpdatedDates { get; set; }
+        public TimeOnly[] StartTimes { get; set; }
+        public DateOnly[] BirthDates { get; set; }
+        public Status[] Statuses { get; set; }
+    }
+
+    enum Status
+    {
+        Active,
+        Inactive,
+        Suspended
+    }
+
+    class Address
+    {
+        public string City { get; set; }
+        public string Country { get; set; }
+    }
+
+    public class ExpressionSerializerTests
+    {
+        private readonly ExpressionSerializer _serializer = new ExpressionSerializer();
+
+        [Fact]
+        public void Serializes_SimpleBinaryExpression()
+        {
+            Expression<Func<int, bool>> expr = e => e > 10;
+            Assert.Equal("e => (e > 10)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_StringEquality()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Name == "John";
+            Assert.Equal("e => (e.Name == \"John\")", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_IntComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Age > 18;
+            Assert.Equal("e => (e.Age > 18)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DoubleComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Salary < 50000.50;
+            Assert.Equal("e => (e.Salary < 50000.5)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_FloatComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Score >= 85.3f;
+            Assert.Equal("e => (e.Score >= 85.3)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DecimalComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Balance <= 1000.75m;
+            Assert.Equal("e => (e.Balance <= 1000.75)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ShortComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Level == 3;
+            Assert.Equal("e => (e.Level == 3)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_LongComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Population > 1000000L;
+            Assert.Equal("e => (e.Population > 1000000)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_EnumComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.AccountStatus == Status.Inactive;
+            Assert.Equal("e => (e.AccountStatus == 1)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayContainsValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Scores.Contains(100);
+            Assert.Equal("e => e.Scores.Contains(100)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayNotContainsValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !e.Scores.Contains(100);
+            Assert.Equal("e => (!(e.Scores.Contains(100)))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayInValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Scores.Intersect(new [] { 100 }).Any();
+            Assert.Equal("e => e.Scores.Intersect(new [] { 100 }).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayNotInValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Scores.Except(new[] { 100 }).Any();
+            Assert.Equal("e => e.Scores.Except(new [] { 100 }).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 100 }.Intersect(e.Scores).Any();
+            Assert.Equal("e => new [] { 100 }.Intersect(e.Scores).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayNotInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 100 }.Except(e.Scores).Any();
+            Assert.Equal("e => new [] { 100 }.Except(e.Scores).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_IntArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 100 }.Intersect(e.Scores).Any();
+            Assert.Equal("e => new [] { 100 }.Intersect(e.Scores).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_IntArrayNotInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !new[] { 100 }.Intersect(e.Scores).Any();
+            Assert.Equal("e => (!(new [] { 100 }.Intersect(e.Scores).Any()))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DoubleArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 99.99 }.Intersect(e.Salaries).Any();
+            Assert.Equal("e => new [] { 99.99 }.Intersect(e.Salaries).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_FloatArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 5.5f }.Intersect(e.Heights).Any();
+            Assert.Equal("e => new [] { 5.5 }.Intersect(e.Heights).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DecimalArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 1000.75m }.Intersect(e.Balances).Any();
+            Assert.Equal("e => new [] { 1000.75 }.Intersect(e.Balances).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ShortArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new [] { (short)3 }.Intersect(e.Levels).Any();
+            Assert.Equal("e => new [] { 3 }.Intersect(e.Levels).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_LongArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new [] { 1000000L }.Intersect(e.Populations).Any();
+            Assert.Equal("e => new [] { 1000000 }.Intersect(e.Populations).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_StringArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { "Alice", "Bob" }.Intersect(e.Names).Any();
+            Assert.Equal("e => (new [] { \"Alice\", \"Bob\" }).Intersect(e.Names).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_GuidArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { Guid.Parse("12345678-1234-1234-1234-123456789abc") }.Intersect(e.Ids).Any();
+            Assert.Equal("e => (new [] { Guid.Parse(\"12345678-1234-1234-1234-123456789abc\") }).Intersect(e.Ids).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DateTimeArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { DateTime.Parse("2023-01-01T00:00:00.000Z") }.Intersect(e.CreatedDates).Any();
+            Assert.Equal("e => (new [] { DateTime.Parse(\"2023-01-01T00:00:00.000Z\") }).Intersect(e.CreatedDates).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DateTimeOffsetArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { DateTimeOffset.Parse("2023-01-01T10:30:00.000+00:00") }.Intersect(e.UpdatedDates).Any();
+            Assert.Equal("e => (new [] { DateTimeOffset.Parse(\"2023-01-01T10:30:00.000+00:00\") }).Intersect(e.UpdatedDates).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DateTimeWithRoundtripKind()
+        {
+            Expression<Func<TestEntity, bool>> expr = e =>
+                DateTime.Parse("2023-01-01T00:00:00.000Z", null, DateTimeStyles.RoundtripKind) > e.CreatedAt;
+
+            Assert.Equal(
+                "e => (DateTime.Parse(\"2023-01-01T00:00:00.000Z\", null, (System.Globalization.DateTimeStyles)128) > e.CreatedAt)",
+                _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_TimeOnlyArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { TimeOnly.Parse("12:00:00") }.Intersect(e.StartTimes).Any();
+            Assert.Equal("e => (new [] { TimeOnly.Parse(\"12:00:00\") }).Intersect(e.StartTimes).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DateOnlyArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { DateOnly.Parse("2000-01-01") }.Intersect(e.BirthDates).Any();
+            Assert.Equal("e => (new [] { DateOnly.Parse(\"2000-01-01\") }).Intersect(e.BirthDates).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_EnumArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { Status.Active, Status.Inactive }.Intersect(e.Statuses).Any();
+            Assert.Equal("e => (new [] { (Radzen.Blazor.Tests.Status)0, (Radzen.Blazor.Tests.Status)1 }).Intersect(e.Statuses).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ListContainsValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Tags.Contains("VIP");
+            Assert.Equal("e => e.Tags.Contains(\"VIP\")", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ListNotContainsValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !e.Tags.Contains("VIP");
+            Assert.Equal("e => (!(e.Tags.Contains(\"VIP\")))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ListAnyCheck()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Children.Any(c => c.Age > 18);
+            Assert.Equal("e => e.Children.Any(c => (c.Age > 18))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ListNotAnyCheck()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !e.Children.Any(c => c.Age > 18);
+            Assert.Equal("e => (!(e.Children.Any(c => (c.Age > 18))))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_EntitySubPropertyCheck()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Address.City == "New York";
+            Assert.Equal("e => (e.Address.City == \"New York\")", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ComplexExpressionWithProperties()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Age > 18 && e.Tags.Contains("Member") || e.Address.City == "London";
+            Assert.Equal("e => (((e.Age > 18) && e.Tags.Contains(\"Member\")) || (e.Address.City == \"London\"))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_NotContains()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !e.Tags.Contains("Member");
+            Assert.Equal("e => (!(e.Tags.Contains(\"Member\")))", _serializer.Serialize(expr));
+        }
+    }
+}

Radzen.Blazor.Tests/FieldsetTests.cs

@@ -184,13 +184,13 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains("SummaryContent", component.Markup);
             Assert.Equal(
-                "",
-                component.Find(".rz-fieldset-content-summary").ParentElement.Attributes.First(attr => attr.Name == "style").Value
+                "false",
+                component.Find(".rz-fieldset-content-summary").ParentElement.ParentElement.Attributes.First(attr => attr.Name == "aria-hidden").Value
             );
         }
 
         [Fact]
-        public void Fieldset_DontRenders_SummaryWhenOpen()
+        public void Fieldset_DoesNotRender_SummaryWhenOpen()
         {
             using var ctx = new TestContext();
             var component = ctx.RenderComponent<RadzenFieldset>();
@@ -210,8 +210,8 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains("SummaryContent", component.Markup);
             Assert.Equal(
-                "display: none",
-                component.Find(".rz-fieldset-content-summary").ParentElement.Attributes.First(attr => attr.Name == "style").Value
+                "true",
+                component.Find(".rz-fieldset-content-summary").ParentElement.ParentElement.Attributes.First(attr => attr.Name == "aria-hidden").Value
             );
         }
     }

Radzen.Blazor.Tests/FileInputTests.cs

@@ -0,0 +1,182 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class FileInputTests
+    {
+        [Fact]
+        public void FileInput_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains(@"rz-fileupload", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_ChooseButton()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains("rz-fileupload-choose", component.Markup);
+            Assert.Contains("rz-button", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_ChooseText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.ChooseText, "Select File");
+            });
+
+            Assert.Contains("Select File", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_DefaultChooseText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains("Choose", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("rz-state-disabled", component.Markup);
+            Assert.Contains("disabled", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_Accept()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Accept, "application/pdf");
+            });
+
+            Assert.Contains("accept=\"application/pdf\"", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_DefaultAccept()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains("accept=\"image/*\"", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_FileInputElement()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains("type=\"file\"", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_Title_WhenSet()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Title, "MyDocument.pdf");
+                parameters.Add(p => p.Value, "data:application/pdf;base64,test");
+            });
+
+            Assert.Contains("MyDocument.pdf", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_FileName_WhenTitleNotSet()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.FileName, "document.pdf");
+                parameters.Add(p => p.Value, "data:application/pdf;base64,test");
+            });
+
+            Assert.Contains("document.pdf", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_DeleteButton_WhenValueSet()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Value, "data:text/plain;base64,test");
+            });
+
+            Assert.Contains("rz-icon-trash", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_CustomDeleteText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.DeleteText, "Remove File");
+                parameters.Add(p => p.Value, "data:text/plain;base64,test");
+            });
+
+            Assert.Contains("title=\"Remove File\"", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_ImagePreview_ForImageFile()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Value, "data:image/png;base64,test");
+            });
+
+            Assert.Contains("<img", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_ImageAlternateText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.ImageAlternateText, "User Photo");
+                parameters.Add(p => p.Value, "data:image/png;base64,test");
+            });
+
+            Assert.Contains("alt=\"User Photo\"", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/FormFieldTests.cs

@@ -0,0 +1,163 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class FormFieldTests
+    {
+        [Fact]
+        public void FormField_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>();
+
+            Assert.Contains(@"rz-form-field", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Text()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Text, "Email Address");
+            });
+
+            Assert.Contains("Email Address", component.Markup);
+            Assert.Contains("rz-form-field-label", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Variant_Outlined()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Variant, Variant.Outlined);
+            });
+
+            Assert.Contains("rz-variant-outlined", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Variant_Filled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Variant, Variant.Filled);
+            });
+
+            Assert.Contains("rz-variant-filled", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Variant_Flat()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Variant, Variant.Flat);
+            });
+
+            Assert.Contains("rz-variant-flat", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Variant_Text()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Variant, Variant.Text);
+            });
+
+            Assert.Contains("rz-variant-text", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_AllowFloatingLabel_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.AllowFloatingLabel, true);
+            });
+
+            Assert.Contains("rz-floating-label", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_AllowFloatingLabel_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.AllowFloatingLabel, false);
+            });
+
+            Assert.DoesNotContain("rz-floating-label", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Component_Attribute()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Component, "email-input");
+            });
+
+            Assert.Contains("for=\"email-input\"", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Helper()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Helper, builder => builder.AddContent(0, "Enter your email address"));
+            });
+
+            Assert.Contains("rz-form-field-helper", component.Markup);
+            Assert.Contains("Enter your email address", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Start()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Start, builder => builder.AddMarkupContent(0, "<span>Start</span>"));
+            });
+
+            Assert.Contains("rz-form-field-start", component.Markup);
+            Assert.Contains("Start", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_End()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.End, builder => builder.AddMarkupContent(0, "<span>End</span>"));
+            });
+
+            Assert.Contains("rz-form-field-end", component.Markup);
+            Assert.Contains("End", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_FormFieldContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>();
+
+            Assert.Contains("rz-form-field-content", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/HeadingTests.cs

@@ -0,0 +1,103 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class HeadingTests
+    {
+        [Fact]
+        public void Heading_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            Assert.Contains(@"rz-heading", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_TextParameter()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            var text = "Test Heading";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
+
+            Assert.Contains(text, component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H1_ByDefault()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            var text = "Heading Text";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
+
+            Assert.Contains("<h1", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H2_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            var text = "Heading 2";
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Text, text);
+                parameters.Add(p => p.Size, "H2");
+            });
+
+            Assert.Contains("<h2", component.Markup);
+            Assert.Contains(text, component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H3_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, "H3"));
+
+            Assert.Contains("<h3", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H4_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, "H4"));
+
+            Assert.Contains("<h4", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H5_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, "H5"));
+
+            Assert.Contains("<h5", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H6_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, "H6"));
+
+            Assert.Contains("<h6", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/HtmlEditorTests.cs

@@ -0,0 +1,104 @@
+using Bunit;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class HtmlEditorTests
+    {
+        [Fact]
+        public void HtmlEditor_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>();
+
+            Assert.Contains(@"rz-html-editor", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_ShowToolbar_True()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.ShowToolbar, true);
+            });
+
+            Assert.Contains("rz-html-editor-toolbar", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_ShowToolbar_False()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.ShowToolbar, false);
+            });
+
+            Assert.DoesNotContain("rz-html-editor-toolbar", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_Mode_Design()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.Mode, HtmlEditorMode.Design);
+            });
+
+            // Design mode shows the content editable div
+            Assert.Contains("contenteditable", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_Mode_Source()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.Mode, HtmlEditorMode.Source);
+            });
+
+            // Source mode shows the textarea for HTML editing
+            Assert.Contains("rz-html-editor-source", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_Disabled_Attribute()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_ContentArea()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>();
+
+            Assert.Contains("rz-html-editor-content", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/ListBoxTests.cs

@@ -0,0 +1,197 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ListBoxTests
+    {
+        class Item
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+        }
+
+        [Fact]
+        public void ListBox_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>();
+
+            Assert.Contains(@"rz-listbox", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_WithData_SimpleList()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Apple", "Banana", "Cherry" };
+            
+            var component = ctx.RenderComponent<RadzenListBox<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("Apple", component.Markup);
+            Assert.Contains("Banana", component.Markup);
+            Assert.Contains("Cherry", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_WithData_CustomTextValueProperties()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "First Item" },
+                new Item { Id = 2, Name = "Second Item" }
+            };
+            
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "Name");
+                parameters.Add(p => p.ValueProperty, "Id");
+            });
+
+            Assert.Contains("First Item", component.Markup);
+            Assert.Contains("Second Item", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_AllowFiltering()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.Data, new List<string> { "Item1", "Item2" });
+            });
+
+            Assert.Contains("rz-listbox-filter", component.Markup);
+            Assert.Contains("rz-listbox-header", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_Disabled_Attribute()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_Multiple_WithSelectAll()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<IEnumerable<int>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.SelectAllText, "Select All Items");
+                parameters.Add(p => p.Data, new List<string> { "Item1", "Item2" });
+            });
+
+            Assert.Contains("Select All Items", component.Markup);
+            Assert.Contains("rz-chkbox", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_FilterPlaceholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.Placeholder, "Select an item");
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.Data, new List<string> { "Item1", "Item2" });
+            });
+
+            Assert.Contains("Select an item", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_Multiple_WithCheckboxes()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2" };
+
+            var component = ctx.RenderComponent<RadzenListBox<IEnumerable<string>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Data, data);
+            });
+
+            // Multiple selection shows checkboxes in header
+            Assert.Contains("rz-listbox-header-w-checkbox", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_ReadOnly()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.ReadOnly, true);
+            });
+
+            Assert.Contains("readonly", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_TabIndex()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>();
+
+            Assert.Contains("tabindex=", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_ListWrapper()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenListBox<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-listbox-list-wrapper", component.Markup);
+            Assert.Contains("rz-listbox-list", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_SearchAriaLabel()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.SearchAriaLabel, "Search items");
+                parameters.Add(p => p.Data, new List<string> { "Item1" });
+            });
+
+            Assert.Contains("aria-label=\"Search items\"", component.Markup);
+        }
+    }
+}
+
+
+

Radzen.Blazor.Tests/MediaQueryTests.cs

@@ -0,0 +1,65 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class MediaQueryTests
+    {
+        [Fact]
+        public void MediaQuery_Renders()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = ctx.RenderComponent<RadzenMediaQuery>(parameters =>
+            {
+                parameters.Add(p => p.Query, "(max-width: 768px)");
+            });
+
+            Assert.NotNull(component.Instance);
+        }
+
+        [Fact]
+        public void MediaQuery_HasQueryParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var query = "(max-width: 1024px)";
+            var component = ctx.RenderComponent<RadzenMediaQuery>(parameters =>
+            {
+                parameters.Add(p => p.Query, query);
+            });
+
+            Assert.Equal(query, component.Instance.Query);
+        }
+
+        [Fact]
+        public void MediaQuery_InvokesChangeCallback()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            bool changeInvoked = false;
+            bool matchResult = false;
+
+            var component = ctx.RenderComponent<RadzenMediaQuery>(parameters =>
+            {
+                parameters.Add(p => p.Query, "(max-width: 768px)");
+                parameters.Add(p => p.Change, EventCallback.Factory.Create<bool>(this, (matches) =>
+                {
+                    changeInvoked = true;
+                    matchResult = matches;
+                }));
+            });
+
+            // Invoke the JSInvokable method directly
+            component.Instance.OnChange(true);
+
+            Assert.True(changeInvoked);
+            Assert.True(matchResult);
+        }
+    }
+}
+

Radzen.Blazor.Tests/MenuTests.cs

@@ -0,0 +1,58 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class MenuTests
+    {
+        [Fact]
+        public void Menu_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenMenu>();
+
+            Assert.Contains(@"rz-menu", component.Markup);
+        }
+
+        [Fact]
+        public void Menu_Renders_Responsive_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenMenu>(parameters =>
+            {
+                parameters.Add(p => p.Responsive, true);
+            });
+
+            Assert.Contains("rz-menu-closed", component.Markup);
+            Assert.Contains("rz-menu-toggle", component.Markup);
+        }
+
+        [Fact]
+        public void Menu_Renders_Responsive_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenMenu>(parameters =>
+            {
+                parameters.Add(p => p.Responsive, false);
+            });
+
+            Assert.DoesNotContain("rz-menu-toggle", component.Markup);
+            Assert.DoesNotContain("rz-menu-closed", component.Markup);
+        }
+
+
+        [Fact]
+        public void Menu_Renders_CustomToggleAriaLabel()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenMenu>(parameters =>
+            {
+                parameters.Add(p => p.Responsive, true);
+                parameters.Add(p => p.ToggleAriaLabel, "Open navigation");
+            });
+
+            Assert.Contains("Open navigation", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/NumericRangeValidatorTests.cs

@@ -16,7 +16,7 @@ namespace Radzen.Blazor.Tests
 
             public string Name { get; set; }
 
-            public FieldIdentifier FieldIdentifier => throw new System.NotImplementedException();
+            public FieldIdentifier FieldIdentifier { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
             public object GetValue()
             {

Radzen.Blazor.Tests/PanelMenuTests.cs

@@ -1,8 +1,9 @@
 using Bunit;
-using Bunit.TestDoubles;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Routing;
 using Microsoft.Extensions.DependencyInjection.Extensions;
+using System.Collections.Generic;
+using System.Linq;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -22,6 +23,9 @@ namespace Radzen.Blazor.Tests
         }
 
         private static string CreatePanelMenu(string currentAbsoluteUrl, NavLinkMatch match, params string[] urls)
+            => CreatePanelMenu(currentAbsoluteUrl, match, new Dictionary<string, bool>(urls.Select(url => new KeyValuePair<string, bool>(url, false))));
+
+        private static string CreatePanelMenu(string currentAbsoluteUrl, NavLinkMatch match, Dictionary<string, bool> urls)
         {
             using var ctx = new TestContext();
 
@@ -30,12 +34,13 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenPanelMenu>();
 
-            component.SetParametersAndRender(parameters => parameters.Add(p => p.Match, match).AddChildContent(builder => 
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Match, match).AddChildContent(builder =>
             {
                 foreach (var url in urls)
                 {
                     builder.OpenComponent<RadzenPanelMenuItem>(0);
-                    builder.AddAttribute(1, nameof(RadzenPanelMenuItem.Path), url);
+                    builder.AddAttribute(1, nameof(RadzenPanelMenuItem.Path), url.Key);
+                    builder.AddAttribute(2, nameof(RadzenPanelMenuItem.Disabled), url.Value);
                     builder.CloseComponent();
                 }
             }));
@@ -55,6 +60,19 @@ namespace Radzen.Blazor.Tests
             Assert.Equal(firstIndex, lastIndex);
         }
 
+        [Fact]
+        public void RadzenPanelMenu_CanDisableMenuItem()
+        {
+            var urls = new Dictionary<string, bool>
+            {
+                {"/datagrid", false},
+                {"/disabled-url", true}
+            };
+            var component = CreatePanelMenu("http://www.example.com/", NavLinkMatch.All, urls);
+
+            Assert.Contains("rz-state-disabled", component);
+        }
+
         [Fact]
         public void RadzenPanelMenu_MatchesQueryStringParameters()
         {

Radzen.Blazor.Tests/PanelTests.cs

@@ -198,14 +198,10 @@ namespace Radzen.Blazor.Tests
             });
 
             Assert.Contains("SummaryContent", component.Markup);
-            Assert.Equal(
-                "display: block",
-                component.Find(".rz-panel-content-summary").ParentElement.Attributes.First(attr => attr.Name == "style").Value
-            );
         }
 
         [Fact]
-        public void Panel_DontRenders_SummaryWhenOpen()
+        public void Panel_DoesNotRender_SummaryWhenOpen()
         {
             using var ctx = new TestContext();
             var component = ctx.RenderComponent<RadzenPanel>();
@@ -225,8 +221,8 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains("SummaryContent", component.Markup);
             Assert.Equal(
-                "display: none",
-                component.Find(".rz-panel-content-summary").ParentElement.Attributes.First(attr => attr.Name == "style").Value
+                "true",
+                component.Find(".rz-panel-content-summary").ParentElement.ParentElement.Attributes.First(attr => attr.Name == "aria-hidden").Value
             );
         }
     }

Radzen.Blazor.Tests/PasswordTests.cs

@@ -171,24 +171,49 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains(@$"autofocus", component.Markup);
         }
-        
+
         [Fact]
         public void Password_Raises_ChangedEvent()
         {
             using var ctx = new TestContext();
-
-            var component = ctx.RenderComponent<RadzenPassword>();
-
-            var raised = false;
+            var hasRaised = false;
             var value = "Test";
             object newValue = null;
 
-            component.SetParametersAndRender(parameters => parameters.Add(p => p.Change, args => { raised = true; newValue = args; }));
+            var component = ctx.RenderComponent<RadzenPassword>(parameters =>
+            {
+                parameters.Add(p => p.Change, args => { hasRaised = true; newValue = args; });
+                parameters.Add(p => p.Immediate, false);
+            });
 
-            component.Find("input").Change(value);
+            var inputElement = component.Find("input");
+            inputElement.Change(value);
 
-            Assert.True(raised);
-            Assert.True(object.Equals(value, newValue));
+            Assert.DoesNotContain("oninput", inputElement.ToMarkup());
+            Assert.True(hasRaised);
+            Assert.Equal(value, newValue);
+        }
+
+        [Fact]
+        public void Password_Raises_InputEvent()
+        {
+            using var ctx = new TestContext();
+            var hasRaised = false;
+            var value = "Test";
+            object newValue = null;
+
+            var component = ctx.RenderComponent<RadzenPassword>(parameters =>
+            {
+                parameters.Add(p => p.Change, args => { hasRaised = true; newValue = args; });
+                parameters.Add(p => p.Immediate, true);
+            });
+
+            var inputElement = component.Find("input");
+            inputElement.Input(value);
+
+            Assert.DoesNotContain("onchange", inputElement.ToMarkup());
+            Assert.True(hasRaised);
+            Assert.Equal(value, newValue);
         }
 
         [Fact]

Radzen.Blazor.Tests/PickListTests.cs

@@ -0,0 +1,161 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+
+namespace Radzen.Blazor.Tests
+{
+    public class PickListTests
+    {
+        class Item
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+        }
+
+        [Fact]
+        public void PickList_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>();
+
+            Assert.Contains(@"rz-picklist", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_SourceAndTargetLists()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>();
+
+            Assert.Contains("rz-picklist-source-wrapper", component.Markup);
+            Assert.Contains("rz-picklist-target-wrapper", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_TransferButtons()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>();
+
+            Assert.Contains("rz-picklist-buttons", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_Orientation_Horizontal()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Horizontal);
+            });
+
+            Assert.Contains("rz-flex-row", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_Orientation_Vertical()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Vertical);
+            });
+
+            Assert.Contains("rz-flex-column", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_AllowFiltering()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "Item 1" }
+            };
+
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.Source, data);
+                parameters.Add(p => p.TextProperty, "Name");
+            });
+
+            Assert.Contains("rz-listbox-filter", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_SourceData()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "Source Item 1" },
+                new Item { Id = 2, Name = "Source Item 2" }
+            };
+
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.Source, data);
+                parameters.Add(p => p.TextProperty, "Name");
+            });
+
+            Assert.Contains("Source Item 1", component.Markup);
+            Assert.Contains("Source Item 2", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_ShowHeader()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.ShowHeader, true);
+                parameters.Add(p => p.SourceHeader, builder => builder.AddContent(0, "Available Items"));
+                parameters.Add(p => p.TargetHeader, builder => builder.AddContent(0, "Selected Items"));
+            });
+
+            Assert.Contains("Available Items", component.Markup);
+            Assert.Contains("Selected Items", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_AllowMoveAll_Buttons()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Item> { new Item { Id = 1, Name = "Item" } };
+
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.AllowMoveAll, true);
+                parameters.Add(p => p.Source, data);
+            });
+
+            // Should have 4 buttons when AllowMoveAll is true
+            var buttonCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rz-button").Count;
+            Assert.True(buttonCount >= 4);
+        }
+
+        [Fact]
+        public void PickList_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/PivotDataGridTests.cs

@@ -0,0 +1,644 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Radzen;
+using Radzen.Blazor;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class PivotDataGridTests
+    {
+        private static readonly List<SalesData> SampleData = new()
+        {
+            new SalesData { Region = "North", Category = "Electronics", Product = "Laptop", Amount = 1000, Year = 2023 },
+            new SalesData { Region = "North", Category = "Electronics", Product = "Laptop", Amount = 1500, Year = 2024 },
+            new SalesData { Region = "South", Category = "Home", Product = "Vacuum", Amount = 500, Year = 2023 }
+        };
+
+        public class SalesData
+        {
+            public string Region { get; set; }
+            public string Category { get; set; }
+            public string Product { get; set; }
+            public double Amount { get; set; }
+            public int Year { get; set; }
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_CssClasses()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx);
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-pivot-data-grid", component.Markup);
+                Assert.Contains("rz-pivot-table", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_RowAndColumnHeaders()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx);
+
+            component.WaitForAssertion(() =>
+            {
+                var table = component.Find(".rz-pivot-content .rz-pivot-table");
+                var headers = table.GetElementsByClassName("rz-pivot-header-text").Select(h => h.TextContent.Trim()).ToList();
+                var aggregateHeaders = table.GetElementsByClassName("rz-pivot-aggregate-header").Select(h => h.TextContent.Trim()).ToList();
+
+                Assert.Contains("Region", headers);
+                Assert.Contains("2023", headers);
+                Assert.Contains("Sales", aggregateHeaders);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowSorting_RendersSortableClass()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowSorting, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var sortableHeaders = component.FindAll(".rz-pivot-header-content.rz-sortable");
+                Assert.NotEmpty(sortableHeaders);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFiltering_RendersFilterIcon()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var filterIcons = component.FindAll(".rz-grid-filter-icon");
+                Assert.NotEmpty(filterIcons);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_AggregateValues()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx);
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("1000", component.Markup);
+                Assert.Contains("1500", component.Markup);
+                Assert.Contains("500", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_DisallowFiltering_HidesFilterIcon()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var filterIcons = component.FindAll(".rz-grid-filter-icon");
+                Assert.Empty(filterIcons);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_DisallowSorting_HidesSortableClass()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowSorting, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var sortableHeaders = component.FindAll(".rz-pivot-header-content.rz-sortable");
+                Assert.Empty(sortableHeaders);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_ShowColumnsTotals_RendersFooter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.ShowColumnsTotals, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var footer = component.FindAll(".rz-pivot-footer");
+                Assert.NotEmpty(footer);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_HideColumnsTotals_NoFooter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.ShowColumnsTotals, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var footer = component.FindAll(".rz-pivot-footer");
+                Assert.Empty(footer);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_DefaultEmptyText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, new List<SalesData>());
+                parameters.Add(p => p.AllowFieldsPicking, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("No records to display.", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_CustomEmptyText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, new List<SalesData>());
+                parameters.Add(p => p.EmptyText, "No data available");
+                parameters.Add(p => p.AllowFieldsPicking, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("No data available", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowPaging_RendersPager()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.PageSize, 2);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-pager", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_DisallowPaging_HidesPager()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.DoesNotContain("rz-pager", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_PagerPosition_Top()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.PagerPosition, PagerPosition.Top);
+                parameters.Add(p => p.PageSize, 2);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-pager", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_PagerPosition_TopAndBottom()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.PagerPosition, PagerPosition.TopAndBottom);
+                parameters.Add(p => p.PageSize, 2);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var pagers = component.FindAll(".rz-pager");
+                Assert.True(pagers.Count >= 1); // Should have at least one pager
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Density_Compact()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.PageSize, 1); // Force pager to show with small page size
+                parameters.Add(p => p.AllowFieldsPicking, false);
+                parameters.Add(p => p.Density, Density.Compact);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-density-compact", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowAlternatingRows_True()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-grid-table-striped", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowAlternatingRows_False()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.DoesNotContain("rz-grid-table-striped", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFieldsPicking_ShowsPanel()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowFieldsPicking, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-panel", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFieldsPicking_False_HidesPanel()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowFieldsPicking, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.DoesNotContain("rz-panel", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_AllowDrillDown()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowDrillDown, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                // Should render pivot content
+                Assert.Contains("rz-pivot-content", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_RowValues()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx);
+
+            component.WaitForAssertion(() =>
+            {
+                var cells = component.FindAll(".rz-pivot-row-header");
+                var cellTexts = cells.Select(c => c.TextContent.Trim()).ToList();
+                
+                Assert.Contains("North", cellTexts);
+                Assert.Contains("South", cellTexts);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_MultipleRows()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, SampleData);
+
+                parameters.Add<RenderFragment>(p => p.Rows, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotRow<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotRow<SalesData>.Property), nameof(SalesData.Region));
+                    builder.AddAttribute(2, nameof(RadzenPivotRow<SalesData>.Title), "Region");
+                    builder.CloseComponent();
+
+                    builder.OpenComponent<RadzenPivotRow<SalesData>>(2);
+                    builder.AddAttribute(3, nameof(RadzenPivotRow<SalesData>.Property), nameof(SalesData.Category));
+                    builder.AddAttribute(4, nameof(RadzenPivotRow<SalesData>.Title), "Category");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Columns, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotColumn<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotColumn<SalesData>.Property), nameof(SalesData.Year));
+                    builder.AddAttribute(2, nameof(RadzenPivotColumn<SalesData>.Title), "Year");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Aggregates, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotAggregate<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotAggregate<SalesData>.Property), nameof(SalesData.Amount));
+                    builder.AddAttribute(2, nameof(RadzenPivotAggregate<SalesData>.Title), "Sales");
+                    builder.AddAttribute(3, nameof(RadzenPivotAggregate<SalesData>.Aggregate), AggregateFunction.Sum);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var headers = component.FindAll(".rz-pivot-header-text").Select(h => h.TextContent.Trim()).ToList();
+                Assert.Contains("Region", headers);
+                Assert.Contains("Category", headers);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_MultipleAggregates()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, SampleData);
+
+                parameters.Add<RenderFragment>(p => p.Rows, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotRow<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotRow<SalesData>.Property), nameof(SalesData.Region));
+                    builder.AddAttribute(2, nameof(RadzenPivotRow<SalesData>.Title), "Region");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Columns, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotColumn<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotColumn<SalesData>.Property), nameof(SalesData.Year));
+                    builder.AddAttribute(2, nameof(RadzenPivotColumn<SalesData>.Title), "Year");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Aggregates, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotAggregate<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotAggregate<SalesData>.Property), nameof(SalesData.Amount));
+                    builder.AddAttribute(2, nameof(RadzenPivotAggregate<SalesData>.Title), "Total Sales");
+                    builder.AddAttribute(3, nameof(RadzenPivotAggregate<SalesData>.Aggregate), AggregateFunction.Sum);
+                    builder.CloseComponent();
+
+                    builder.OpenComponent<RadzenPivotAggregate<SalesData>>(4);
+                    builder.AddAttribute(5, nameof(RadzenPivotAggregate<SalesData>.Property), nameof(SalesData.Amount));
+                    builder.AddAttribute(6, nameof(RadzenPivotAggregate<SalesData>.Title), "Count Sales");
+                    builder.AddAttribute(7, nameof(RadzenPivotAggregate<SalesData>.Aggregate), AggregateFunction.Count);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var aggregateHeaders = component.FindAll(".rz-pivot-aggregate-header").Select(h => h.TextContent.Trim()).ToList();
+                Assert.Contains("Total Sales", aggregateHeaders);
+                Assert.Contains("Count Sales", aggregateHeaders);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_AlternatingRowClasses()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-pivot-row-even", component.Markup);
+                Assert.Contains("rz-pivot-row-odd", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_PageSize_DefaultsTo10()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.Equal(10, grid.PageSize);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowSorting_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowSorting);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFiltering_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowFiltering);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowAlternatingRows_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowAlternatingRows);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowDrillDown_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowDrillDown);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFieldsPicking_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowFieldsPicking);
+        }
+
+        private static IRenderedComponent<RadzenPivotDataGrid<SalesData>> RenderPivotDataGrid(TestContext ctx, Action<ComponentParameterCollectionBuilder<RadzenPivotDataGrid<SalesData>>>? configure = null)
+        {
+            return ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, SampleData);
+
+                parameters.Add<RenderFragment>(p => p.Rows, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotRow<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotRow<SalesData>.Property), nameof(SalesData.Region));
+                    builder.AddAttribute(2, nameof(RadzenPivotRow<SalesData>.Title), "Region");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Columns, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotColumn<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotColumn<SalesData>.Property), nameof(SalesData.Year));
+                    builder.AddAttribute(2, nameof(RadzenPivotColumn<SalesData>.Title), "Year");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Aggregates, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotAggregate<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotAggregate<SalesData>.Property), nameof(SalesData.Amount));
+                    builder.AddAttribute(2, nameof(RadzenPivotAggregate<SalesData>.Title), "Sales");
+                    builder.AddAttribute(3, nameof(RadzenPivotAggregate<SalesData>.Aggregate), AggregateFunction.Sum);
+                    builder.CloseComponent();
+                });
+
+                configure?.Invoke(parameters);
+            });
+        }
+    }
+}
+

Radzen.Blazor.Tests/ProfileMenuItemTests.cs

@@ -0,0 +1,120 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ProfileMenuItemTests
+    {
+        [Fact]
+        public void ProfileMenuItem_Renders_TextParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Text", "Profile");
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("Profile", component.Markup);
+        }
+
+        [Fact]
+        public void ProfileMenuItem_Renders_IconParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Icon", "account_circle");
+                    builder.AddAttribute(2, "Text", "Profile");
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("account_circle", component.Markup);
+        }
+
+        [Fact]
+        public void ProfileMenuItem_Template_OverridesText()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Text", "This should not appear");
+                    builder.AddAttribute(2, "Template", (RenderFragment)((templateBuilder) =>
+                    {
+                        templateBuilder.OpenElement(0, "span");
+                        templateBuilder.AddAttribute(1, "class", "template-content");
+                        templateBuilder.AddContent(2, "Template Content");
+                        templateBuilder.CloseElement();
+                    }));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Template should be rendered
+            Assert.Contains("template-content", component.Markup);
+            // Text should not be rendered in navigation-item-text span when Template is present
+            Assert.DoesNotContain("<span class=\"rz-navigation-item-text\">This should not appear</span>", component.Markup);
+        }
+
+        [Fact]
+        public void ProfileMenuItem_Renders_TemplateWithSwitch()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Icon", "settings");
+                    builder.AddAttribute(2, "Template", (RenderFragment)((templateBuilder) =>
+                    {
+                        templateBuilder.OpenComponent<RadzenSwitch>(0);
+                        templateBuilder.CloseComponent();
+                    }));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Icon should still be rendered
+            Assert.Contains("settings", component.Markup);
+            // Switch should be rendered from template
+            Assert.Contains("rz-switch", component.Markup);
+        }
+
+        [Fact]
+        public void ProfileMenuItem_Renders_PathParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Text", "Settings");
+                    builder.AddAttribute(2, "Path", "/settings");
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("href=\"/settings\"", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/ProgressBarTests.cs

@@ -142,5 +142,45 @@ namespace Radzen.Blazor.Tests
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Mode, ProgressBarMode.Indeterminate));
             Assert.Contains(@$"rz-progressbar-info", component.Markup);
         }
+
+        [Fact]
+        public void ProgressBar_Renders_ShowValue_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenProgressBar>(parameters =>
+            {
+                parameters.Add(p => p.ShowValue, true);
+                parameters.Add(p => p.Value, 50);
+            });
+
+            Assert.Contains("rz-progressbar-label", component.Markup);
+            Assert.Contains("50%", component.Markup);
+        }
+
+        [Fact]
+        public void ProgressBar_Renders_ShowValue_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenProgressBar>(parameters =>
+            {
+                parameters.Add(p => p.ShowValue, false);
+                parameters.Add(p => p.Value, 50);
+            });
+
+            Assert.DoesNotContain("rz-progressbar-label", component.Markup);
+        }
+
+        [Fact]
+        public void ProgressBar_Renders_Template()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenProgressBar>(parameters =>
+            {
+                parameters.Add(p => p.Value, 75);
+                parameters.Add(p => p.Template, builder => builder.AddContent(0, "Custom: 75%"));
+            });
+
+            Assert.Contains("Custom: 75%", component.Markup);
+        }
     }
 }

Radzen.Blazor.Tests/PropertyAccessTests.cs

@@ -113,5 +113,43 @@ namespace Radzen.Blazor.Tests
         {
             public List<string> Values { get; set; }
         }
+
+        [Fact]
+        public void GetProperty_Should_Resolve_DescriptionProperty()
+        {
+            var descriptionProperty = PropertyAccess.GetProperty(typeof(ISimpleInterface), nameof(ISimpleInterface.Description));
+
+            Assert.NotNull(descriptionProperty);
+        }
+
+        [Fact]
+        public void GetProperty_Should_Resolve_NameProperty()
+        {
+            var nameProperty = PropertyAccess.GetProperty(typeof(ISimpleInterface), nameof(ISimpleInterface.Name));
+
+            Assert.NotNull(nameProperty);
+        }
+
+        [Fact]
+        public void GetProperty_Should_Resolve_IdProperty()
+        {
+            var idProperty = PropertyAccess.GetProperty(typeof(ISimpleInterface), nameof(ISimpleBaseInterface.Id));
+            Assert.NotNull(idProperty);
+        }
+
+        interface ISimpleInterface : ISimpleNestedInterface
+        {
+            string Description { get; set; }
+        }
+
+        interface ISimpleNestedInterface : ISimpleBaseInterface
+        {
+            string Name { get; set; }
+        }
+
+        interface ISimpleBaseInterface
+        {
+            int Id { get; set; }
+        }
     }
 }

Radzen.Blazor.Tests/RadioButtonListTests.cs

@@ -0,0 +1,62 @@
+using Bunit;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class RadioButtonListTests
+    {
+        [Fact]
+        public void RadioButtonList_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRadioButtonList<int>>();
+
+            Assert.Contains(@"rz-radio-button-list", component.Markup);
+        }
+
+        [Fact]
+        public void RadioButtonList_Renders_Orientation()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRadioButtonList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenRadioButtonListItem<int>>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Horizontal));
+            // Orientation is applied via RadzenStack which uses flex-direction
+            Assert.Contains("rz-flex-row", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Vertical));
+            Assert.Contains("rz-flex-column", component.Markup);
+        }
+
+        [Fact]
+        public void RadioButtonList_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRadioButtonList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenRadioButtonListItem<int>>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            // Disabled class is on the radio button items
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/Radzen.Blazor.Tests.csproj

@@ -1,13 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
     <PackageReference Include="bunit.web" Version="1.36.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">

Radzen.Blazor.Tests/RatingTests.cs

@@ -0,0 +1,82 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class RatingTests
+    {
+        [Fact]
+        public void Rating_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            Assert.Contains(@"rz-rating", component.Markup);
+        }
+
+        [Fact]
+        public void Rating_Renders_Stars()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Stars, 5));
+
+            // Should render 5 star icons (rzi-star or rzi-star-o) + 1 clear button icon = 6 total
+            var starCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rz-rating-icon").Count;
+            Assert.Equal(6, starCount); // 5 stars + 1 clear button
+        }
+
+        [Fact]
+        public void Rating_Renders_CustomStarCount()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Stars, 10));
+
+            var starCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rz-rating-icon").Count;
+            Assert.Equal(11, starCount); // 10 stars + 1 clear button
+        }
+
+        [Fact]
+        public void Rating_Renders_Value()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Value, 3);
+                parameters.Add(p => p.Stars, 5);
+            });
+
+            // Should have 3 filled stars (rzi-star) and 2 outline stars (rzi-star-o)
+            var filledStars = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rzi-star\"").Count;
+            Assert.Equal(3, filledStars);
+        }
+
+        [Fact]
+        public void Rating_Renders_ReadOnly()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ReadOnly, true));
+
+            Assert.Contains("rz-state-readonly", component.Markup);
+        }
+
+        [Fact]
+        public void Rating_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Disabled, true));
+
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/RowTests.cs

@@ -0,0 +1,63 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class RowTests
+    {
+        [Fact]
+        public void Row_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>();
+
+            Assert.Contains(@"rz-row", component.Markup);
+        }
+
+        [Fact]
+        public void Row_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>(parameters =>
+            {
+                parameters.AddChildContent("<div>Row Content</div>");
+            });
+
+            Assert.Contains("Row Content", component.Markup);
+        }
+
+        [Fact]
+        public void Row_Renders_Gap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Gap, "2rem"));
+
+            Assert.Contains("--rz-gap:2rem", component.Markup);
+        }
+
+        [Fact]
+        public void Row_Renders_RowGap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.RowGap, "1.5rem"));
+
+            Assert.Contains("--rz-row-gap:1.5rem", component.Markup);
+        }
+
+        [Fact]
+        public void Row_Renders_ColumnGap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Gap, "1rem"));
+
+            Assert.Contains("--rz-gap:1rem", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/SecurityCodeTests.cs

@@ -0,0 +1,45 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SecurityCodeTests
+    {
+        [Fact]
+        public void SecurityCode_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenSecurityCode>();
+
+            Assert.Contains(@"rz-security-code", component.Markup);
+        }
+
+        [Fact]
+        public void SecurityCode_Renders_Count()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenSecurityCode>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Count, 6));
+
+            // Should render 6 input boxes + 1 hidden input for form submission = 7 total
+            var inputCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "<input").Count;
+            Assert.Equal(7, inputCount);
+        }
+
+        [Fact]
+        public void SecurityCode_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenSecurityCode>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Disabled, true));
+
+            Assert.Contains("disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/SelectBarTests.cs

@@ -0,0 +1,83 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SelectBarTests
+    {
+        [Fact]
+        public void SelectBar_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSelectBar<int>>();
+
+            Assert.Contains(@"rz-selectbar", component.Markup);
+        }
+
+        [Fact]
+        public void SelectBar_Renders_Orientation()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSelectBar<int>>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenSelectBarItem>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Horizontal));
+            Assert.Contains("rz-selectbar-horizontal", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Vertical));
+            Assert.Contains("rz-selectbar-vertical", component.Markup);
+        }
+
+        [Fact]
+        public void SelectBar_Renders_Multiple()
+        {
+            using var ctx = new TestContext();
+            // When Multiple is true, TValue should be IEnumerable<T>
+            var component = ctx.RenderComponent<RadzenSelectBar<System.Collections.Generic.IEnumerable<int>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenSelectBarItem>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.NotNull(component.Instance);
+            Assert.True(component.Instance.Multiple);
+        }
+
+        [Fact]
+        public void SelectBar_Renders_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSelectBar<int>>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenSelectBarItem>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, ButtonSize.Small));
+            Assert.Contains("rz-button-sm", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, ButtonSize.Large));
+            Assert.Contains("rz-button-lg", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/SidebarToggleTests.cs

@@ -0,0 +1,65 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SidebarToggleTests
+    {
+        [Fact]
+        public void SidebarToggle_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            Assert.Contains(@"rz-sidebar-toggle", component.Markup);
+        }
+
+        [Fact]
+        public void SidebarToggle_Renders_DefaultIcon()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            Assert.Contains("menu", component.Markup);
+        }
+
+        [Fact]
+        public void SidebarToggle_Renders_CustomIcon()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            var icon = "close";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, icon));
+
+            Assert.Contains(icon, component.Markup);
+        }
+
+        [Fact]
+        public void SidebarToggle_Renders_AriaLabel()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            var ariaLabel = "Toggle Navigation";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ToggleAriaLabel, ariaLabel));
+
+            Assert.Contains($"aria-label=\"{ariaLabel}\"", component.Markup);
+        }
+
+        [Fact]
+        public void SidebarToggle_Raises_ClickEvent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            var clicked = false;
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Click, args => { clicked = true; }));
+
+            component.Find("button").Click();
+
+            Assert.True(clicked);
+        }
+    }
+}
+

Radzen.Blazor.Tests/SkeletonTests.cs

@@ -0,0 +1,158 @@
+using Bunit;
+using Radzen.Blazor.Rendering;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SkeletonTests
+    {
+        [Fact]
+        public void Skeleton_Renders_CssClass()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains("rz-skeleton-text", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_TypeParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, SkeletonVariant.Circular));
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains("rz-skeleton-circular", component.Markup);
+        }
+
+        [Theory]
+        [InlineData(SkeletonVariant.Text, "rz-skeleton-text")]
+        [InlineData(SkeletonVariant.Circular, "rz-skeleton-circular")]
+        [InlineData(SkeletonVariant.Rectangular, "rz-skeleton-rectangular")]
+        public void Skeleton_Renders_AllTypes(SkeletonVariant type, string expectedClass)
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>(parameters => parameters.Add(p => p.Variant, type));
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains(expectedClass, component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_AnimationParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Animation, SkeletonAnimation.Wave));
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains("rz-skeleton-wave", component.Markup);
+        }
+
+        [Theory]
+        [InlineData(SkeletonAnimation.Wave, "rz-skeleton-wave")]
+        [InlineData(SkeletonAnimation.Pulse, "rz-skeleton-pulse")]
+        public void Skeleton_Renders_AllAnimations(SkeletonAnimation animation, string expectedClass)
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>(parameters => parameters.Add(p => p.Animation, animation));
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains(expectedClass, component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_StyleParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            var style = "width: 200px; height: 20px;";
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Style, style));
+
+            Assert.Contains($"style=\"{style}\"", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_VisibleParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            // Should be visible by default
+            Assert.Contains("rz-skeleton", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Visible, false));
+
+            // Should not render when not visible
+            Assert.DoesNotContain("rz-skeleton", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_UnmatchedParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("data-testid", "skeleton-test"));
+
+            Assert.Contains("data-testid=\"skeleton-test\"", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_DefaultType_IsText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            // Should render with text type by default
+            Assert.Contains("rz-skeleton-text", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_DefaultAnimation_IsNone()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            // Should not render animation classes by default
+            Assert.DoesNotContain("rz-skeleton-wave", component.Markup);
+            Assert.DoesNotContain("rz-skeleton-pulse", component.Markup);
+        }
+    }
+} 

Radzen.Blazor.Tests/SliderTests.cs

@@ -89,5 +89,71 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains(@$"autofocus", component.Markup);
         }
+
+        [Fact]
+        public void Slider_Renders_Orientation_Vertical()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Vertical);
+            });
+
+            Assert.Contains("rz-slider-vertical", component.Markup);
+        }
+
+        [Fact]
+        public void Slider_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void Slider_Renders_SliderHandle()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>();
+
+            Assert.Contains("rz-slider-handle", component.Markup);
+        }
+
+        [Fact]
+        public void Slider_Renders_SliderRange()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>();
+
+            Assert.Contains("rz-slider-range", component.Markup);
+        }
+
+        [Fact]
+        public void Slider_Renders_TabIndex()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>();
+
+            Assert.Contains("tabindex=\"0\"", component.Markup);
+        }
     }
 }

Radzen.Blazor.Tests/SplitterTests.cs

@@ -0,0 +1,42 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SplitterTests
+    {
+        [Fact]
+        public void Splitter_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSplitter>();
+
+            Assert.Contains(@"rz-splitter", component.Markup);
+        }
+
+        [Fact]
+        public void Splitter_Renders_Orientation_Horizontal()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSplitter>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Horizontal);
+            });
+
+            Assert.Contains("rz-splitter-horizontal", component.Markup);
+        }
+
+        [Fact]
+        public void Splitter_Renders_Orientation_Vertical()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSplitter>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Vertical);
+            });
+
+            Assert.Contains("rz-splitter-vertical", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/StackTests.cs

@@ -0,0 +1,98 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class StackTests
+    {
+        [Fact]
+        public void Stack_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            Assert.Contains(@"rz-stack", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>(parameters =>
+            {
+                parameters.AddChildContent("<div>Stack Content</div>");
+            });
+
+            Assert.Contains("Stack Content", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_Orientation()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Horizontal));
+            Assert.Contains("rz-flex-row", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Vertical));
+            Assert.Contains("rz-flex-column", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_Gap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Gap, "1.5rem"));
+
+            Assert.Contains("--rz-gap:1.5rem", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_AlignItems()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlignItems, AlignItems.Center));
+
+            Assert.Contains("rz-align-items-center", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_JustifyContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.JustifyContent, JustifyContent.SpaceBetween));
+
+            Assert.Contains("rz-justify-content-space-between", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_Wrap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Wrap, FlexWrap.Wrap));
+
+            Assert.Contains("flex-wrap:wrap", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_Reverse()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Reverse, true));
+
+            Assert.Contains("rz-flex-column-reverse", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/StepsTests.cs

@@ -0,0 +1,70 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class StepsTests
+    {
+        [Fact]
+        public void Steps_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>();
+
+            Assert.Contains(@"rz-steps", component.Markup);
+        }
+
+        [Fact]
+        public void Steps_Renders_ShowStepsButtons_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>(parameters =>
+            {
+                parameters.Add(p => p.ShowStepsButtons, true);
+            });
+
+            Assert.Contains("rz-steps-buttons", component.Markup);
+        }
+
+        [Fact]
+        public void Steps_Renders_ShowStepsButtons_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>(parameters =>
+            {
+                parameters.Add(p => p.ShowStepsButtons, false);
+            });
+
+            Assert.DoesNotContain("rz-steps-buttons", component.Markup);
+        }
+
+        [Fact]
+        public void Steps_Renders_StepsButtons()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>(parameters =>
+            {
+                parameters.Add(p => p.ShowStepsButtons, true);
+            });
+
+            Assert.Contains("rz-steps-prev", component.Markup);
+            Assert.Contains("rz-steps-next", component.Markup);
+        }
+
+        [Fact]
+        public void Steps_Renders_CustomButtonText()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>(parameters =>
+            {
+                parameters.Add(p => p.ShowStepsButtons, true);
+                parameters.Add(p => p.NextText, "Continue");
+                parameters.Add(p => p.PreviousText, "Back");
+            });
+
+            Assert.Contains("Continue", component.Markup);
+            Assert.Contains("Back", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/TableTests.cs

@@ -0,0 +1,100 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class TableTests
+    {
+        [Fact]
+        public void Table_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>();
+
+            Assert.Contains(@"rz-datatable", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_TableElement()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>();
+
+            Assert.Contains("rz-grid-table", component.Markup);
+            Assert.Contains("<table", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_GridLines_None()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.GridLines, DataGridGridLines.None);
+            });
+
+            Assert.Contains("rz-grid-gridlines-none", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_GridLines_Horizontal()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.GridLines, DataGridGridLines.Horizontal);
+            });
+
+            Assert.Contains("rz-grid-gridlines-horizontal", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_GridLines_Vertical()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.GridLines, DataGridGridLines.Vertical);
+            });
+
+            Assert.Contains("rz-grid-gridlines-vertical", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_GridLines_Both()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.GridLines, DataGridGridLines.Both);
+            });
+
+            Assert.Contains("rz-grid-gridlines-both", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_AllowAlternatingRows_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, true);
+            });
+
+            Assert.Contains("rz-grid-table-striped", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_AllowAlternatingRows_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, false);
+            });
+
+            Assert.DoesNotContain("rz-grid-table-striped", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/TabsTests.cs

@@ -0,0 +1,108 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class TabsTests
+    {
+        [Fact]
+        public void Tabs_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>();
+
+            Assert.Contains(@"rz-tabview", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_Top()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.Top);
+            });
+
+            Assert.Contains("rz-tabview-top", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_Bottom()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.Bottom);
+            });
+
+            Assert.Contains("rz-tabview-bottom", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_Left()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.Left);
+            });
+
+            Assert.Contains("rz-tabview-left", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_Right()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.Right);
+            });
+
+            Assert.Contains("rz-tabview-right", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_TopRight()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.TopRight);
+            });
+
+            Assert.Contains("rz-tabview-top-right", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_BottomRight()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.BottomRight);
+            });
+
+            Assert.Contains("rz-tabview-bottom-right", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabNav()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>();
+
+            Assert.Contains("rz-tabview-nav", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPanels()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>();
+
+            Assert.Contains("rz-tabview-panels", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/TextBoxTests.cs

@@ -1,4 +1,6 @@
 using Bunit;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Forms;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -29,6 +31,26 @@ namespace Radzen.Blazor.Tests
             Assert.Contains(@$"value=""{value}""", component.Markup);
         }
 
+        [Fact]
+        public void TextboxCanSetFieldIdentifier()
+        {
+            using var ctx = new TestContext();
+
+            var editContext = new EditContext(ctx);
+            var fieldIdentifier = new FieldIdentifier(ctx, nameof(RadzenTextBox.Value));
+            ctx.RenderTree.TryAdd<CascadingValue<EditContext>>(parameters =>
+            {
+                parameters.Add(e => e.Value, editContext);
+            });
+
+            var component = ctx.RenderComponent<RadzenTextBox>(parameters =>
+            {
+                parameters.Add(p => p.FieldIdentifier, fieldIdentifier);
+            });
+
+            Assert.Equal(component.Instance.FieldIdentifier, fieldIdentifier);
+        }
+
         [Fact]
         public void TextBox_Renders_StyleParameter()
         {

Radzen.Blazor.Tests/TimelineTests.cs

@@ -0,0 +1,71 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class TimelineTests
+    {
+        [Fact]
+        public void Timeline_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            Assert.Contains(@"rz-timeline", component.Markup);
+        }
+
+        [Fact]
+        public void Timeline_Renders_Orientation()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Horizontal));
+            Assert.Contains("rz-timeline-row", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Vertical));
+            Assert.Contains("rz-timeline-column", component.Markup);
+        }
+
+        [Fact]
+        public void Timeline_Renders_LinePosition()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.LinePosition, LinePosition.Start));
+            Assert.Contains("rz-timeline-start", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.LinePosition, LinePosition.End));
+            Assert.Contains("rz-timeline-end", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.LinePosition, LinePosition.Center));
+            Assert.Contains("rz-timeline-center", component.Markup);
+        }
+
+        [Fact]
+        public void Timeline_Renders_AlignItems()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlignItems, AlignItems.Start));
+            Assert.Contains("rz-timeline-align-items-start", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlignItems, AlignItems.Center));
+            Assert.Contains("rz-timeline-align-items-center", component.Markup);
+        }
+
+        [Fact]
+        public void Timeline_Renders_Reverse()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Reverse, true));
+
+            Assert.Contains("rz-timeline-reverse", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/TocTests.cs

@@ -0,0 +1,27 @@
+using Bunit;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class TocTests
+    {
+        [Fact]
+        public void TocItem_Renders_With_Attributes()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTocItem>(parameters =>
+            {
+                parameters.Add(p => p.Attributes, new Dictionary<string, object>
+                {
+                    { "data-enhance-nav", "false" },
+                    { "aria-label", "Table of Contents Item" }
+                });
+            });
+
+            Assert.Contains("data-enhance-nav=\"false\"", component.Markup);
+            Assert.Contains("aria-label=\"Table of Contents Item\"", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/ToggleButtonTests.cs

@@ -0,0 +1,98 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ToggleButtonTests
+    {
+        [Fact]
+        public void ToggleButton_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            Assert.Contains(@"rz-button", component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_TextParameter()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            var text = "Toggle Me";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
+
+            Assert.Contains(text, component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_IconParameter()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            var icon = "toggle_on";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, icon));
+
+            Assert.Contains(icon, component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_Value()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Value, true));
+
+            Assert.Contains("rz-state-active", component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Disabled, true));
+
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_ButtonStyle()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ButtonStyle, ButtonStyle.Primary));
+            Assert.Contains("rz-primary", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ButtonStyle, ButtonStyle.Success));
+            Assert.Contains("rz-success", component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Raises_ChangeEvent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            var changed = false;
+            bool newValue = false;
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Change, args =>
+            {
+                changed = true;
+                newValue = args;
+            }));
+
+            component.Find("button").Click();
+
+            Assert.True(changed);
+            Assert.True(newValue);
+        }
+    }
+}
+

Radzen.Blazor.Tests/TreeTests.cs

@@ -0,0 +1,211 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Radzen.Blazor.Tests
+{
+    public class TreeTests
+    {
+        class Category
+        {
+            public string Name { get; set; }
+            public List<Product> Products { get; set; } = new List<Product>();
+        }
+
+        class Product
+        {
+            public string Name { get; set; }
+        }
+
+        class Employee
+        {
+            public string FirstName { get; set; }
+            public string LastName { get; set; }
+            public List<Employee> Employees { get; set; } = new List<Employee>();
+        }
+
+        [Fact]
+        public void Tree_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTree>();
+
+            Assert.Contains(@"rz-tree", component.Markup);
+        }
+
+        [Fact]
+        public void Tree_Renders_TreeContainer()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTree>();
+
+            Assert.Contains("rz-tree-container", component.Markup);
+        }
+
+        [Fact]
+        public void Tree_Renders_TabIndex()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTree>();
+
+            Assert.Contains("tabindex=\"0\"", component.Markup);
+        }
+
+        [Fact]
+        public void Tree_Renders_WithData_SingleLevel()
+        {
+            using var ctx = new TestContext();
+            var data = new List<Category>
+            {
+                new Category { Name = "Electronics" },
+                new Category { Name = "Clothing" }
+            };
+
+            var component = ctx.RenderComponent<RadzenTree>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenTreeLevel>(0);
+                    builder.AddAttribute(1, "TextProperty", "Name");
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("Electronics", component.Markup);
+            Assert.Contains("Clothing", component.Markup);
+        }
+
+        [Fact]
+        public void Tree_Renders_WithData_HierarchicalData()
+        {
+            using var ctx = new TestContext();
+            var data = new List<Category>
+            {
+                new Category 
+                { 
+                    Name = "Electronics",
+                    Products = new List<Product>
+                    {
+                        new Product { Name = "Laptop" },
+                        new Product { Name = "Phone" }
+                    }
+                }
+            };
+
+            var component = ctx.RenderComponent<RadzenTree>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenTreeLevel>(0);
+                    builder.AddAttribute(1, "TextProperty", "Name");
+                    builder.AddAttribute(2, "ChildrenProperty", "Products");
+                    builder.CloseComponent();
+
+                    builder.OpenComponent<RadzenTreeLevel>(3);
+                    builder.AddAttribute(4, "TextProperty", "Name");
+                    builder.AddAttribute(5, "HasChildren", (object product) => false);
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("Electronics", component.Markup);
+        }
+
+        [Fact]
+        public void Tree_Renders_WithData_SelfReferencing()
+        {
+            using var ctx = new TestContext();
+            var data = new List<Employee>
+            {
+                new Employee 
+                { 
+                    FirstName = "Nancy", 
+                    LastName = "Davolio",
+                    Employees = new List<Employee>
+                    {
+                        new Employee { FirstName = "Andrew", LastName = "Fuller" }
+                    }
+                }
+            };
+
+            var component = ctx.RenderComponent<RadzenTree>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenTreeLevel>(0);
+                    builder.AddAttribute(1, "TextProperty", "LastName");
+                    builder.AddAttribute(2, "ChildrenProperty", "Employees");
+                    builder.AddAttribute(3, "HasChildren", (object e) => (e as Employee).Employees.Any());
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("Davolio", component.Markup);
+        }
+
+        [Fact]
+        public void Tree_Renders_WithCheckBoxes()
+        {
+            using var ctx = new TestContext();
+            var data = new List<Category>
+            {
+                new Category { Name = "Electronics" }
+            };
+
+            var component = ctx.RenderComponent<RadzenTree>(parameters =>
+            {
+                parameters.Add(p => p.AllowCheckBoxes, true);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenTreeLevel>(0);
+                    builder.AddAttribute(1, "TextProperty", "Name");
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("rz-chkbox", component.Markup);
+        }
+
+        [Fact]
+        public void Tree_Renders_WithExpandableItems()
+        {
+            using var ctx = new TestContext();
+            var data = new List<Category>
+            {
+                new Category 
+                { 
+                    Name = "Electronics",
+                    Products = new List<Product>
+                    {
+                        new Product { Name = "Laptop" }
+                    }
+                }
+            };
+
+            var component = ctx.RenderComponent<RadzenTree>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenTreeLevel>(0);
+                    builder.AddAttribute(1, "TextProperty", "Name");
+                    builder.AddAttribute(2, "ChildrenProperty", "Products");
+                    builder.CloseComponent();
+
+                    builder.OpenComponent<RadzenTreeLevel>(3);
+                    builder.AddAttribute(4, "TextProperty", "Name");
+                    builder.CloseComponent();
+                });
+            });
+
+            // Expandable items should have a toggle icon
+            Assert.Contains("rz-tree-toggler", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/UploadTests.cs

@@ -0,0 +1,95 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class UploadTests
+    {
+        [Fact]
+        public void Upload_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenUpload>();
+
+            Assert.Contains(@"rz-fileupload", component.Markup);
+        }
+
+        [Fact]
+        public void Upload_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenUpload>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void Upload_Renders_ChooseText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenUpload>(parameters =>
+            {
+                parameters.Add(p => p.ChooseText, "Select Files");
+            });
+
+            Assert.Contains("Select Files", component.Markup);
+        }
+
+        [Fact]
+        public void Upload_Renders_DefaultChooseText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenUpload>();
+
+            Assert.Contains("Choose", component.Markup);
+        }
+
+        [Fact]
+        public void Upload_Renders_Icon()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenUpload>(parameters =>
+            {
+                parameters.Add(p => p.Icon, "upload");
+            });
+
+            Assert.Contains("upload", component.Markup);
+            Assert.Contains("rzi", component.Markup);
+        }
+
+        [Fact]
+        public void Upload_Renders_Multiple_Attribute()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenUpload>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+            });
+
+            Assert.Contains("multiple", component.Markup);
+        }
+
+        [Fact]
+        public void Upload_Renders_Accept_Attribute()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenUpload>(parameters =>
+            {
+                parameters.Add(p => p.Accept, "image/*");
+            });
+
+            Assert.Contains("accept=\"image/*\"", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor/AIChatService.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.IO;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using System.Linq;
+
+namespace Radzen;
+
+/// <summary>
+/// Service for interacting with AI chat models to get completions with conversation memory.
+/// </summary>
+public class AIChatService(IServiceProvider serviceProvider, IOptions<AIChatServiceOptions> options) : IAIChatService
+{
+    private readonly Dictionary<string, ConversationSession> sessions = new();
+    private readonly object sessionsLock = new();
+
+    /// <summary>
+    /// Gets the configuration options for the chat streaming service.
+    /// </summary>
+    public AIChatServiceOptions Options => options.Value;
+
+    /// <inheritdoc />
+    public async IAsyncEnumerable<string> GetCompletionsAsync(string userInput, string sessionId = null, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default, string model = null, string systemPrompt = null, double? temperature = null, int? maxTokens = null, string endpoint = null, string proxy = null, string apiKey = null, string apiKeyHeader = null)
+    {
+        if (string.IsNullOrWhiteSpace(userInput))
+        {
+            throw new ArgumentException("User input cannot be null or empty.", nameof(userInput));
+        }
+
+        // Get or create session
+        var session = GetOrCreateSession(sessionId);
+
+        // Add user message to conversation history
+        session.AddMessage("user", userInput);
+
+        // Use runtime parameters or fall back to configured options
+        var url = proxy ?? Options.Proxy ?? endpoint ?? Options.Endpoint;
+        var effectiveApiKey = apiKey ?? Options.ApiKey;
+        var effectiveApiKeyHeader = apiKeyHeader ?? Options.ApiKeyHeader;
+
+        // Get formatted messages including conversation history
+        var messages = session.GetFormattedMessages(systemPrompt ?? Options.SystemPrompt);
+
+        var payload = new
+        {
+            model = model ?? Options.Model,
+            messages = messages,
+            temperature = temperature ?? Options.Temperature,
+            max_tokens = maxTokens ?? Options.MaxTokens,
+            stream = true
+        };
+
+        var request = new HttpRequestMessage(HttpMethod.Post, url)
+        {
+            Content = new StringContent(JsonSerializer.Serialize(payload, new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull }), Encoding.UTF8, "application/json")
+        };
+
+        if (!string.IsNullOrEmpty(effectiveApiKey))
+        {
+            if (string.Equals(effectiveApiKeyHeader, "Authorization", StringComparison.OrdinalIgnoreCase))
+            {
+                request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", effectiveApiKey);
+            }
+            else
+            {
+                request.Headers.Add(effectiveApiKeyHeader, effectiveApiKey);
+            }
+        }
+
+        var httpClient = serviceProvider.GetRequiredService<HttpClient>();
+        var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+
+        if (!response.IsSuccessStatusCode)
+        {
+            throw new Exception($"Chat stream failed: {await response.Content.ReadAsStringAsync(cancellationToken)}");
+        }
+
+        using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+        using var reader = new StreamReader(stream);
+
+        var assistantResponse = new StringBuilder();
+
+        string line;
+        while ((line = await reader.ReadLineAsync()) is not null && !cancellationToken.IsCancellationRequested)
+        {
+            if (string.IsNullOrWhiteSpace(line) || !line.StartsWith("data:"))
+            {
+                continue;
+            }
+
+            var json = line["data:".Length..].Trim();
+
+            if (json == "[DONE]")
+            {
+                break;
+            }
+
+            var content = ParseStreamingResponse(json);
+            if (!string.IsNullOrEmpty(content))
+            {
+                assistantResponse.Append(content);
+                yield return content;
+            }
+        }
+
+        // Add assistant response to conversation history
+        if (assistantResponse.Length > 0)
+        {
+            session.AddMessage("assistant", assistantResponse.ToString());
+        }
+    }
+
+    /// <inheritdoc />
+    public ConversationSession GetOrCreateSession(string sessionId = null)
+    {
+        lock (sessionsLock)
+        {
+            if (string.IsNullOrEmpty(sessionId))
+            {
+                sessionId = Guid.NewGuid().ToString();
+            }
+
+            if (!sessions.TryGetValue(sessionId, out var session))
+            {
+                session = new ConversationSession
+                {
+                    Id = sessionId,
+                    MaxMessages = Options.MaxMessages
+                };
+                sessions[sessionId] = session;
+            }
+
+            return session;
+        }
+    }
+
+    /// <inheritdoc />
+    public void ClearSession(string sessionId)
+    {
+        lock (sessionsLock)
+        {
+            if (sessions.TryGetValue(sessionId, out var session))
+            {
+                session.Clear();
+            }
+        }
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<ConversationSession> GetActiveSessions()
+    {
+        lock (sessionsLock)
+        {
+            return sessions.Values.ToList();
+        }
+    }
+
+    /// <inheritdoc />
+    public void CleanupOldSessions(int maxAgeHours = 24)
+    {
+        lock (sessionsLock)
+        {
+            var cutoffTime = DateTime.Now.AddHours(-maxAgeHours);
+            var sessionsToRemove = sessions.Values
+                .Where(s => s.LastUpdated < cutoffTime)
+                .Select(s => s.Id)
+                .ToList();
+
+            foreach (var sessionId in sessionsToRemove)
+            {
+                sessions.Remove(sessionId);
+            }
+        }
+    }
+
+    private static string ParseStreamingResponse(string json)
+    {
+        try
+        {
+            var doc = JsonDocument.Parse(json);
+            var root = doc.RootElement;
+
+            if (!root.TryGetProperty("choices", out var choices) || choices.GetArrayLength() == 0)
+            {
+                return string.Empty;
+            }
+
+            var firstChoice = choices[0];
+
+            if (!firstChoice.TryGetProperty("delta", out var delta))
+            {
+                return string.Empty;
+            }
+
+            if (delta.TryGetProperty("content", out var contentElement))
+            {
+                return contentElement.GetString() ?? string.Empty;
+            }
+
+            return string.Empty;
+        }
+        catch
+        {
+            return string.Empty;
+        }
+    }
+}

Radzen.Blazor/AIChatServiceExtensions.cs

@@ -0,0 +1,48 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Radzen;
+
+/// <summary>
+/// Extension methods for configuring AIChatService in the dependency injection container.
+/// </summary>
+public static class AIChatServiceExtensions
+{
+    /// <summary>
+    /// Adds the AIChatService to the service collection with the specified configuration.
+    /// </summary>
+    /// <param name="services">The service collection.</param>
+    /// <param name="configureOptions">The action to configure the AIChatService options.</param>
+    /// <returns>The updated service collection.</returns>
+    public static IServiceCollection AddAIChatService(this IServiceCollection services, Action<AIChatServiceOptions> configureOptions)
+    {
+        if (services == null)
+        {
+            throw new ArgumentNullException(nameof(services));
+        }
+
+        if (configureOptions == null)
+        {
+            throw new ArgumentNullException(nameof(configureOptions));
+        }
+
+        services.Configure(configureOptions);
+        services.AddScoped<IAIChatService, AIChatService>();
+
+        return services;
+    }
+
+    /// <summary>
+    /// Adds the AIChatService to the service collection with default options.
+    /// </summary>
+    /// <param name="services">The service collection.</param>
+    /// <returns>The updated service collection.</returns>
+    public static IServiceCollection AddAIChatService(this IServiceCollection services)
+    {
+        services.AddOptions<AIChatServiceOptions>();
+        services.AddScoped<IAIChatService, AIChatService>();
+
+        return services;
+    }
+}
+

Radzen.Blazor/AIChatServiceOptions.cs

@@ -0,0 +1,58 @@
+namespace Radzen;
+
+/// <summary>
+/// Configuration options for the <see cref="AIChatService"/>.
+/// </summary>
+public class AIChatServiceOptions
+{
+    /// <summary>
+    /// Gets or sets the endpoint URL for the AI service.
+    /// </summary>
+    public string Endpoint { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the proxy URL for the AI service, if any. If set, this will override the Endpoint.
+    /// </summary>
+    public string Proxy { get; set; } = null;
+
+    /// <summary>
+    /// Gets or sets the API key for authentication with the AI service.
+    /// </summary>
+    public string ApiKey { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the header name for the API key (e.g., 'Authorization' or 'api-key').
+    /// </summary>
+    public string ApiKeyHeader { get; set; } = "Authorization";
+
+    /// <summary>
+    /// Gets or sets the model name to use for executing chat completions (e.g., 'gpt-3.5-turbo').
+    /// </summary>
+    public string Model { get; set; }
+
+    /// <summary>
+    /// Gets or sets the system prompt for the AI assistant.
+    /// </summary>
+    public string SystemPrompt { get; set; } = "You are a helpful AI code assistant.";
+
+    /// <summary>
+    /// Gets or sets the temperature for the AI model (0.0 to 2.0). Set to 0.0 for deterministic responses, higher values for more creative outputs.
+    /// </summary>
+    public double Temperature { get; set; } = 0.7;
+
+    /// <summary>
+    /// Gets or sets the maximum number of tokens to generate in the response.
+    /// </summary>
+    public int? MaxTokens { get; set; }
+
+    /// <summary>
+    /// Gets or sets the maximum number of messages to keep in conversation memory.
+    /// </summary>
+    public int MaxMessages { get; set; } = 50;
+
+    /// <summary>
+    /// Gets or sets the maximum age in hours for conversation sessions before cleanup.
+    /// </summary>
+    public int SessionMaxAgeHours { get; set; } = 24;
+}
+

Radzen.Blazor/AggregateFunction.cs

@@ -0,0 +1,43 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the aggregate function for pivot values.
+/// </summary>
+public enum AggregateFunction
+{
+    /// <summary>
+    /// Sum of values.
+    /// </summary>
+    Sum,
+
+    /// <summary>
+    /// Count of items.
+    /// </summary>
+    Count,
+
+    /// <summary>
+    /// Average of values.
+    /// </summary>
+    Average,
+
+    /// <summary>
+    /// Minimum value.
+    /// </summary>
+    Min,
+
+    /// <summary>
+    /// Maximum value.
+    /// </summary>
+    Max,
+
+    /// <summary>
+    /// First value.
+    /// </summary>
+    First,
+
+    /// <summary>
+    /// Last value.
+    /// </summary>
+    Last
+}
+

Radzen.Blazor/AlertSize.cs

@@ -0,0 +1,28 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the size of a <see cref="Radzen.Blazor.RadzenAlert" />.
+/// </summary>
+public enum AlertSize
+{
+    /// <summary>
+    /// The smallest alert.
+    /// </summary>
+    ExtraSmall,
+
+    /// <summary>
+    /// A alert smaller than the default.
+    /// </summary>
+    Small,
+
+    /// <summary>
+    /// The default size of an alert.
+    /// </summary>
+    Medium,
+
+    /// <summary>
+    /// An alert larger than the default.
+    /// </summary>
+    Large
+}
+

Radzen.Blazor/AlertStyle.cs

@@ -0,0 +1,53 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the display style or severity of a <see cref="Radzen.Blazor.RadzenAlert" />. Affects the visual styling of RadzenAlert (background and text color).
+/// </summary>
+public enum AlertStyle
+{
+    /// <summary>
+    /// Primary styling. Similar to primary buttons.
+    /// </summary>
+    Primary,
+
+    /// <summary>
+    /// Secondary styling. Similar to secondary buttons.
+    /// </summary>
+    Secondary,
+
+    /// <summary>
+    /// Light styling. Similar to light buttons.
+    /// </summary>
+    Light,
+
+    /// <summary>
+    /// Base styling. Similar to base buttons.
+    /// </summary>
+    Base,
+
+    /// <summary>
+    /// Dark styling. Similar to dark buttons.
+    /// </summary>
+    Dark,
+
+    /// <summary>
+    /// Success styling.
+    /// </summary>
+    Success,
+
+    /// <summary>
+    /// Danger styling.
+    /// </summary>
+    Danger,
+
+    /// <summary>
+    /// Warning styling.
+    /// </summary>
+    Warning,
+
+    /// <summary>
+    /// Informative styling.
+    /// </summary>
+    Info
+}
+

Radzen.Blazor/AlignItems.cs

@@ -0,0 +1,33 @@
+namespace Radzen;
+
+/// <summary>
+/// Represents the alignment of Stack items.
+/// </summary>
+public enum AlignItems
+{
+    /// <summary>
+    /// Normal items alignment.
+    /// </summary>
+    Normal,
+
+    /// <summary>
+    /// Center items alignment.
+    /// </summary>
+    Center,
+
+    /// <summary>
+    /// Start items alignment.
+    /// </summary>
+    Start,
+
+    /// <summary>
+    /// End items alignment.
+    /// </summary>
+    End,
+
+    /// <summary>
+    /// Stretch items alignment.
+    /// </summary>
+    Stretch
+}
+

Radzen.Blazor/AutoCompleteType.cs

@@ -1,17 +1,12 @@
 namespace Radzen.Blazor
 {
     /// <summary>
-    /// The <c>AutomCompleteType</c> is a string-associated enum of
-    /// browser-supported autocomplete attribute values.
-    /// </summary>
-    /// <remarks>
-    /// This class lists the autocomplete attirbute options allowing
-    /// developers to provide the browser with guidance on how to pre-populate
-    /// the form fields. It is a class rather than a simpler enum to associate
-    /// each option with the string the browser expects. For more information
-    /// please review the list of options (https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete)
+    /// The <c>AutomCompleteType</c> is a string-associated enum of browser-supported autocomplete attribute values.
+    /// Lists the autocomplete attribute options allowing developers to provide the browser with guidance on how to pre-populate the form fields.
+    /// It is a class rather than a simpler enum to associate each option with the string the browser expects.
+    /// For more information please review the list of options (https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete)
     /// and the spec (https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill).
-    /// </remarks>
+    /// </summary>
     public enum AutoCompleteType
     {
         /// <summary>Autocomplete is disabled. </summary>

Radzen.Blazor/BadgeStyle.cs

@@ -0,0 +1,53 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the display style of a <see cref="Radzen.Blazor.RadzenBadge" />. Affects the visual styling of RadzenBadge (background and text color).
+/// </summary>
+public enum BadgeStyle
+{
+    /// <summary>
+    /// Primary styling. Similar to primary buttons.
+    /// </summary>
+    Primary,
+
+    /// <summary>
+    /// Secondary styling. Similar to secondary buttons.
+    /// </summary>
+    Secondary,
+
+    /// <summary>
+    /// Light styling. Similar to light buttons.
+    /// </summary>
+    Light,
+
+    /// <summary>
+    /// Base styling. Similar to base buttons.
+    /// </summary>
+    Base,
+
+    /// <summary>
+    /// Dark styling. Similar to dark buttons.
+    /// </summary>
+    Dark,
+
+    /// <summary>
+    /// Success styling.
+    /// </summary>
+    Success,
+
+    /// <summary>
+    /// Danger styling.
+    /// </summary>
+    Danger,
+
+    /// <summary>
+    /// Warning styling.
+    /// </summary>
+    Warning,
+
+    /// <summary>
+    /// Informative styling.
+    /// </summary>
+    Info
+}
+

Radzen.Blazor/ButtonSize.cs

@@ -0,0 +1,28 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the size of a <see cref="Radzen.Blazor.RadzenButton" />.
+/// </summary>
+public enum ButtonSize
+{
+    /// <summary>
+    /// The default size of a button.
+    /// </summary>
+    Medium,
+
+    /// <summary>
+    /// A button larger than the default.
+    /// </summary>
+    Large,
+
+    /// <summary>
+    /// A button smaller than the default.
+    /// </summary>
+    Small,
+
+    /// <summary>
+    /// The smallest button.
+    /// </summary>
+    ExtraSmall
+}
+

Radzen.Blazor/ButtonStyle.cs

@@ -0,0 +1,53 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the display style of a <see cref="Radzen.Blazor.RadzenButton" />. Affects the visual styling of RadzenButton (background and text color).
+/// </summary>
+public enum ButtonStyle
+{
+    /// <summary>
+    /// A primary button. Clicking it performs the primary action in a form or dialog (e.g. "save").
+    /// </summary>
+    Primary,
+
+    /// <summary>
+    /// A secondary button. Clicking it performs a secondary action in a form or dialog (e.g. close a dialog or cancel a form).
+    /// </summary>
+    Secondary,
+
+    /// <summary>
+    /// A button with lighter styling.
+    /// </summary>
+    Light,
+
+    /// <summary>
+    /// The base UI styling.
+    /// </summary>
+    Base,
+
+    /// <summary>
+    /// A button with dark styling.
+    /// </summary>
+    Dark,
+
+    /// <summary>
+    /// A button with success styling.
+    /// </summary>
+    Success,
+
+    /// <summary>
+    /// A button which represents a dangerous action e.g. "delete".
+    /// </summary>
+    Danger,
+
+    /// <summary>
+    /// A button with warning styling.
+    /// </summary>
+    Warning,
+
+    /// <summary>
+    /// A button with informative styling.
+    /// </summary>
+    Info
+}
+

Radzen.Blazor/ButtonType.cs

@@ -0,0 +1,23 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the type of a <see cref="Radzen.Blazor.RadzenButton" />. Renders as the <c>type</c> HTML attribute.
+/// </summary>
+public enum ButtonType
+{
+    /// <summary>
+    /// Generic button which does not submit its parent form.
+    /// </summary>
+    Button,
+
+    /// <summary>
+    /// Clicking a submit button submits its parent form.
+    /// </summary>
+    Submit,
+
+    /// <summary>
+    /// Clicking a reset button clears the value of all inputs in its parent form.
+    /// </summary>
+    Reset
+}
+

Radzen.Blazor/ChatMessage.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace Radzen.Blazor;
+
+/// <summary>
+/// Represents a chat message in the RadzenAIChat component.
+/// </summary>
+public class ChatMessage
+{
+    /// <summary>
+    /// Gets or sets the unique identifier for the message.
+    /// </summary>
+    public string Id { get; set; } = Guid.NewGuid().ToString();
+
+    /// <summary>
+    /// Gets or sets the content of the message.
+    /// </summary>
+    public string Content { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets whether this message is from the user.
+    /// </summary>
+    public bool IsUser { get; set; }
+
+    /// <summary>
+    /// Gets or sets the ID of the user who sent the message.
+    /// </summary>
+    public string UserId { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the timestamp when the message was created.
+    /// </summary>
+    public DateTime Timestamp { get; set; } = DateTime.Now;
+
+    /// <summary>
+    /// Gets or sets whether this message is currently streaming.
+    /// </summary>
+    public bool IsStreaming { get; set; }
+    /// <summary>
+    /// Gets or sets the role associated with the message (e.g., "user", "assistant").
+    /// </summary>
+    public string Role { get; set; }
+}

Radzen.Blazor/CollectionFilterMode.cs

@@ -0,0 +1,18 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies how the filter should be applied to a collection of items.
+/// </summary>
+public enum CollectionFilterMode
+{
+    /// <summary>
+    /// The filter condition is satisfied if at least one item in the collection matches.
+    /// </summary>
+    Any,
+
+    /// <summary>
+    /// The filter condition is satisfied only if all items in the collection match.
+    /// </summary>
+    All
+}
+

Radzen.Blazor/Colors.cs

@@ -0,0 +1,258 @@
+namespace Radzen;
+
+/// <summary>
+/// Colors.
+/// </summary>
+public static class Colors
+{
+    /// <summary>
+    /// Primary.
+    /// </summary>
+    public const string Primary = "var(--rz-primary)";
+
+    /// <summary>
+    /// Primary lighter.
+    /// </summary>
+    public const string PrimaryLighter = "var(--rz-primary-lighter)";
+
+    /// <summary>
+    /// Primary light.
+    /// </summary>
+    public const string PrimaryLight = "var(--rz-primary-light)";
+
+    /// <summary>
+    /// Primary dark.
+    /// </summary>
+    public const string PrimaryDark = "var(--rz-primary-dark)";
+
+    /// <summary>
+    /// Primary darker.
+    /// </summary>
+    public const string PrimaryDarker = "var(--rz-primary-darker)";
+
+    /// <summary>
+    /// Secondary.
+    /// </summary>
+    public const string Secondary = "var(--rz-secondary)";
+
+    /// <summary>
+    /// Secondary lighter.
+    /// </summary>
+    public const string SecondaryLighter = "var(--rz-secondary-lighter)";
+
+    /// <summary>
+    /// Secondary light.
+    /// </summary>
+    public const string SecondaryLight = "var(--rz-secondary-light)";
+
+    /// <summary>
+    /// Secondary dark.
+    /// </summary>
+    public const string SecondaryDark = "var(--rz-secondary-dark)";
+
+    /// <summary>
+    /// Secondary darker.
+    /// </summary>
+    public const string SecondaryDarker = "var(--rz-secondary-darker)";
+
+    /// <summary>
+    /// Info.
+    /// </summary>
+    public const string Info = "var(--rz-info)";
+
+    /// <summary>
+    /// Info lighter.
+    /// </summary>
+    public const string InfoLighter = "var(--rz-info-lighter)";
+
+    /// <summary>
+    /// Info light.
+    /// </summary>
+    public const string InfoLight = "var(--rz-info-light)";
+
+    /// <summary>
+    /// Info dark.
+    /// </summary>
+    public const string InfoDark = "var(--rz-info-dark)";
+
+    /// <summary>
+    /// Info darker.
+    /// </summary>
+    public const string InfoDarker = "var(--rz-info-darker)";
+
+    /// <summary>
+    /// Success.
+    /// </summary>
+    public const string Success = "var(--rz-success)";
+
+    /// <summary>
+    /// Success lighter.
+    /// </summary>
+    public const string SuccessLighter = "var(--rz-success-lighter)";
+
+    /// <summary>
+    /// Success light.
+    /// </summary>
+    public const string SuccessLight = "var(--rz-success-light)";
+
+    /// <summary>
+    /// Success dark.
+    /// </summary>
+    public const string SuccessDark = "var(--rz-success-dark)";
+
+    /// <summary>
+    /// Success darker.
+    /// </summary>
+    public const string SuccessDarker = "var(--rz-success-darker)";
+
+    /// <summary>
+    /// Warning.
+    /// </summary>
+    public const string Warning = "var(--rz-warning)";
+
+    /// <summary>
+    /// Warning lighter.
+    /// </summary>
+    public const string WarningLighter = "var(--rz-warning-lighter)";
+
+    /// <summary>
+    /// Warning light.
+    /// </summary>
+    public const string WarningLight = "var(--rz-warning-light)";
+
+    /// <summary>
+    /// Warning dark.
+    /// </summary>
+    public const string WarningDark = "var(--rz-warning-dark)";
+
+    /// <summary>
+    /// Warning darker.
+    /// </summary>
+    public const string WarningDarker = "var(--rz-warning-darker)";
+
+    /// <summary>
+    /// Danger.
+    /// </summary>
+    public const string Danger = "var(--rz-danger)";
+
+    /// <summary>
+    /// Danger lighter.
+    /// </summary>
+    public const string DangerLighter = "var(--rz-danger-lighter)";
+
+    /// <summary>
+    /// Danger light.
+    /// </summary>
+    public const string DangerLight = "var(--rz-danger-light)";
+
+    /// <summary>
+    /// Danger dark.
+    /// </summary>
+    public const string DangerDark = "var(--rz-danger-dark)";
+
+    /// <summary>
+    /// Danger darker.
+    /// </summary>
+    public const string DangerDarker = "var(--rz-danger-darker)";
+
+    /// <summary>
+    /// White.
+    /// </summary>
+    public const string White = "var(--rz-white)";
+
+    /// <summary>
+    /// Black.
+    /// </summary>
+    public const string Black = "var(--rz-black)";
+
+    /// <summary>
+    /// Base 50.
+    /// </summary>
+    public const string Base50 = "var(--rz-base-50)";
+
+    /// <summary>
+    /// Base 100.
+    /// </summary>
+    public const string Base100 = "var(--rz-base-100)";
+
+    /// <summary>
+    /// Base 200.
+    /// </summary>
+    public const string Base200 = "var(--rz-base-200)";
+
+    /// <summary>
+    /// Base 300.
+    /// </summary>
+    public const string Base300 = "var(--rz-base-300)";
+
+    /// <summary>
+    /// Base 400.
+    /// </summary>
+    public const string Base400 = "var(--rz-base-400)";
+
+    /// <summary>
+    /// Base 500.
+    /// </summary>
+    public const string Base500 = "var(--rz-base-500)";
+
+    /// <summary>
+    /// Base 600.
+    /// </summary>
+    public const string Base600 = "var(--rz-base-600)";
+
+    /// <summary>
+    /// Base 700.
+    /// </summary>
+    public const string Base700 = "var(--rz-base-700)";
+
+    /// <summary>
+    /// Base 800.
+    /// </summary>
+    public const string Base800 = "var(--rz-base-800)";
+
+    /// <summary>
+    /// Base 900.
+    /// </summary>
+    public const string Base900 = "var(--rz-base-900)";
+
+    /// <summary>
+    /// Series1.
+    /// </summary>
+    public const string Series1 = "var(--rz-series-1)";
+
+    /// <summary>
+    /// Series2.
+    /// </summary>
+    public const string Series2 = "var(--rz-series-2)";
+
+    /// <summary>
+    /// Series3.
+    /// </summary>
+    public const string Series3 = "var(--rz-series-3)";
+
+    /// <summary>
+    /// Series4.
+    /// </summary>
+    public const string Series4 = "var(--rz-series-4)";
+
+    /// <summary>
+    /// Series5.
+    /// </summary>
+    public const string Series5 = "var(--rz-series-5)";
+
+    /// <summary>
+    /// Series6.
+    /// </summary>
+    public const string Series6 = "var(--rz-series-6)";
+
+    /// <summary>
+    /// Series7.
+    /// </summary>
+    public const string Series7 = "var(--rz-series-7)";
+
+    /// <summary>
+    /// Series8.
+    /// </summary>
+    public const string Series8 = "var(--rz-series-8)";
+}
+

Radzen.Blazor/CompositeFilterDescriptor.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+
+namespace Radzen;
+
+/// <summary>
+/// Represents a filter in a component that supports filtering.
+/// </summary>
+public class CompositeFilterDescriptor
+{
+    /// <summary>
+    /// Gets or sets the name of the filtered property.
+    /// </summary>
+    /// <value>The property.</value>
+    public string Property { get; set; }
+
+    /// <summary>
+    /// Gets or sets the property type.
+    /// </summary>
+    /// <value>The property type.</value>
+    public Type Type { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the filtered property.
+    /// </summary>
+    /// <value>The property.</value>
+    public string FilterProperty { get; set; }
+
+    /// <summary>
+    /// Gets or sets the value to filter by.
+    /// </summary>
+    /// <value>The filter value.</value>
+    public object FilterValue { get; set; }
+
+    /// <summary>
+    /// Gets or sets the operator which will compare the property value with <see cref="FilterValue" />.
+    /// </summary>
+    /// <value>The filter operator.</value>
+    public FilterOperator? FilterOperator { get; set; }
+
+    /// <summary>
+    /// Gets or sets the logic used to combine the outcome of filtering by <see cref="FilterValue" />.
+    /// </summary>
+    /// <value>The logical filter operator.</value>
+    public LogicalFilterOperator LogicalFilterOperator { get; set; }
+
+    /// <summary>
+    /// Gets or sets the filters.
+    /// </summary>
+    /// <value>The filters.</value>
+    public IEnumerable<CompositeFilterDescriptor> Filters { get; set; }
+}
+

Radzen.Blazor/ConversationSession.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Represents a conversation session with memory.
+/// </summary>
+public class ConversationSession
+{
+    /// <summary>
+    /// Gets or sets the unique identifier for the conversation session.
+    /// </summary>
+    public string Id { get; set; } = Guid.NewGuid().ToString();
+
+    /// <summary>
+    /// Gets or sets the list of messages in the conversation.
+    /// </summary>
+    public List<ChatMessage> Messages { get; set; } = new();
+
+    /// <summary>
+    /// Gets or sets the timestamp when the conversation was created.
+    /// </summary>
+    public DateTime CreatedAt { get; set; } = DateTime.Now;
+
+    /// <summary>
+    /// Gets or sets the timestamp when the conversation was last updated.
+    /// </summary>
+    public DateTime LastUpdated { get; set; } = DateTime.Now;
+
+    /// <summary>
+    /// Gets or sets the maximum number of messages to keep in memory.
+    /// </summary>
+    public int MaxMessages { get; set; } = 50;
+
+    /// <summary>
+    /// Adds a message to the conversation and manages memory limits.
+    /// </summary>
+    /// <param name="role">The role of the message sender.</param>
+    /// <param name="content">The message content.</param>
+    public void AddMessage(string role, string content)
+    {
+        Messages.Add(new ChatMessage
+        {
+            UserId = role,
+            Role = role,
+            IsUser = role == "user",
+            Content = content,
+            Timestamp = DateTime.Now
+        });
+
+        LastUpdated = DateTime.Now;
+
+        // Remove oldest messages if we exceed the limit
+        while (Messages.Count > MaxMessages)
+        {
+            Messages.RemoveAt(0);
+        }
+    }
+
+    /// <summary>
+    /// Clears all messages from the conversation.
+    /// </summary>
+    public void Clear()
+    {
+        Messages.Clear();
+        LastUpdated = DateTime.Now;
+    }
+
+    /// <summary>
+    /// Gets the conversation messages formatted for the AI API.
+    /// </summary>
+    /// <param name="systemPrompt">The system prompt to include.</param>
+    /// <returns>A list of message objects for the AI API.</returns>
+    public List<object> GetFormattedMessages(string systemPrompt)
+    {
+        var messages = new List<object>();
+
+        // Add system message
+        messages.Add(new { role = "system", content = systemPrompt });
+
+        // Add conversation messages
+        foreach (var message in Messages)
+        {
+            messages.Add(new { role = message.Role, content = message.Content });
+        }
+
+        return messages;
+    }
+}
+

Radzen.Blazor/ConvertType.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace Radzen;
+
+/// <summary>
+/// Converts values to different types. Used internally.
+/// </summary>
+public static class ConvertType
+{
+    /// <summary>
+    /// Changes the type of an object.
+    /// </summary>
+    /// <param name="value">The value.</param>
+    /// <param name="type">The type.</param>
+    /// <param name="culture">The culture.</param>
+    /// <returns>System.Object</returns>
+    public static object ChangeType(object value, Type type, CultureInfo culture = null)
+    {
+        if (culture == null)
+        {
+            culture = CultureInfo.CurrentCulture;
+        }
+        if (value == null && Nullable.GetUnderlyingType(type) != null)
+        {
+            return value;
+        }
+
+        if ((Nullable.GetUnderlyingType(type) ?? type) == typeof(Guid) && value is string)
+        {
+            return Guid.Parse((string)value);
+        }
+
+        if (Nullable.GetUnderlyingType(type)?.IsEnum == true)
+        {
+            return Enum.Parse(Nullable.GetUnderlyingType(type), value.ToString());
+        }
+
+        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+        {
+            Type itemType = type.GetGenericArguments()[0];
+            var enumerable = value as IEnumerable<object>;
+
+            if (enumerable != null)
+            {
+                return enumerable.AsQueryable().Cast(itemType);
+            }
+        }
+
+        return value is IConvertible ? Convert.ChangeType(value, Nullable.GetUnderlyingType(type) ?? type, culture) : value;
+    }
+}
+

Radzen.Blazor/CoordinateSystem.cs

@@ -0,0 +1,18 @@
+namespace Radzen;
+
+/// <summary>
+/// CoordinateSystem enum
+/// </summary>
+public enum CoordinateSystem
+{
+    /// <summary>
+    /// Cartesian CoordinateSystem
+    /// </summary>
+    Cartesian,
+
+    /// <summary>
+    /// Polar CoordinateSystem
+    /// </summary>
+    Polar
+}
+

Radzen.Blazor/DataBoundFormComponent.cs

@@ -103,13 +103,13 @@ namespace Radzen
         /// <summary>
         /// The value
         /// </summary>
-        object _value;
+        private T _value = default;
         /// <summary>
         /// Gets or sets the value.
         /// </summary>
         /// <value>The value.</value>
         [Parameter]
-        public object Value
+        public T Value
         {
             get
             {
@@ -117,10 +117,14 @@ namespace Radzen
             }
             set
             {
-                if (_value != value)
+                if (value == null || value.Equals("null"))
                 {
-                    _value = object.Equals(value, "null") ? null : value;
+                    _value = default;
+                    return;
                 }
+
+                if (!value.Equals(_value))
+                    _value = value;
             }
         }
 
@@ -185,7 +189,7 @@ namespace Radzen
                 if (_data != value)
                 {
                     _view = null;
-                    _value = null;
+                    _value = default;
                     _data = value;
                     StateHasChanged();
                 }
@@ -271,6 +275,8 @@ namespace Radzen
             }
         }
 
+        internal IEnumerable GetView() => View;
+
         /// <summary>
         /// Gets or sets the edit context.
         /// </summary>
@@ -282,7 +288,8 @@ namespace Radzen
         /// Gets the field identifier.
         /// </summary>
         /// <value>The field identifier.</value>
-        public FieldIdentifier FieldIdentifier { get; private set; }
+        [Parameter]
+        public FieldIdentifier FieldIdentifier { get; set; }
 
         /// <summary>
         /// Gets or sets the value expression.
@@ -297,26 +304,25 @@ namespace Radzen
         /// <returns>A Task representing the asynchronous operation.</returns>
         public override async Task SetParametersAsync(ParameterView parameters)
         {
-            var searchTextChanged = parameters.DidParameterChange(nameof(SearchText), SearchText);
-            if (searchTextChanged)
-            {
-                searchText = parameters.GetValueOrDefault<string>(SearchText);
-            }
-
+            // check for changes before setting the properties through the base call
             var dataChanged = parameters.DidParameterChange(nameof(Data), Data);
+            var disabledChanged = parameters.DidParameterChange(nameof(Disabled), Disabled);
 
+            // allow the base class to process parameters and set the properties
+            // after this call the parameters object should be considered stale
+            await base.SetParametersAsync(parameters);
+
+            // handle changes
             if (dataChanged)
             {
                 await OnDataChanged();
             }
 
-            var disabledChanged = parameters.DidParameterChange(nameof(Disabled), Disabled);
-
-            var result = base.SetParametersAsync(parameters);
-
-            if (EditContext != null && ValueExpression != null && FieldIdentifier.Model != EditContext.Model)
+            if (EditContext != null && (ValueExpression != null || ValueChanged.HasDelegate) && FieldIdentifier.Model != EditContext.Model)
             {
-                FieldIdentifier = FieldIdentifier.Create(ValueExpression);
+                FieldIdentifier = ValueExpression != null
+                    ? FieldIdentifier.Create(ValueExpression)
+                    : FieldIdentifier.Create(() => Value);
                 EditContext.OnValidationStateChanged -= ValidationStateChanged;
                 EditContext.OnValidationStateChanged += ValidationStateChanged;
             }
@@ -325,8 +331,6 @@ namespace Radzen
             {
                 FormFieldContext?.DisabledChanged(Disabled);
             }
-
-            await result;
         }
 
         /// <summary>

Radzen.Blazor/DataGridCellMouseEventArgs.cs

@@ -0,0 +1,21 @@
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="RadzenDataGrid{TItem}.CellContextMenu" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridCellMouseEventArgs<T> : Microsoft.AspNetCore.Components.Web.MouseEventArgs
+{
+    /// <summary>
+    /// Gets the data item which the clicked DataGrid row represents.
+    /// </summary>
+    public T Data { get; internal set; }
+
+    /// <summary>
+    /// Gets the RadzenDataGridColumn which this cells represents.
+    /// </summary>
+    public RadzenDataGridColumn<T> Column { get; internal set; }
+}
+

Radzen.Blazor/DataGridCellRenderEventArgs.cs

@@ -0,0 +1,16 @@
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="RadzenDataGrid{TItem}.CellRender" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridCellRenderEventArgs<T> : RowRenderEventArgs<T>
+{
+    /// <summary>
+    /// Gets the RadzenDataGridColumn which this cells represents.
+    /// </summary>
+    public RadzenDataGridColumn<T> Column { get; internal set; }
+}
+

Radzen.Blazor/DataGridChildData.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace Radzen;
+
+/// <summary>
+/// Internal class for managing hierarchical child data in DataGrid.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+internal class DataGridChildData<T>
+{
+    /// <summary>
+    /// Gets or sets the parent child data.
+    /// </summary>
+    internal DataGridChildData<T> ParentChildData { get; set; }
+
+    /// <summary>
+    /// Gets or sets the level.
+    /// </summary>
+    internal int Level { get; set; }
+
+    /// <summary>
+    /// Gets or sets the data.
+    /// </summary>
+    internal IEnumerable<T> Data { get; set; }
+}
+

Radzen.Blazor/DataGridColumnFilterEventArgs.cs

@@ -0,0 +1,41 @@
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="RadzenDataGrid{TItem}.Filter" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridColumnFilterEventArgs<T>
+{
+    /// <summary>
+    /// Gets the filtered RadzenDataGridColumn.
+    /// </summary>
+    public RadzenDataGridColumn<T> Column { get; internal set; }
+
+    /// <summary>
+    /// Gets the new filter value of the filtered column.
+    /// </summary>
+    public object FilterValue { get; internal set; }
+
+    /// <summary>
+    /// Gets the new second filter value of the filtered column.
+    /// </summary>
+    public object SecondFilterValue { get; internal set; }
+
+    /// <summary>
+    /// Gets the new filter operator of the filtered column.
+    /// </summary>
+    public FilterOperator FilterOperator { get; internal set; }
+
+    /// <summary>
+    /// Gets the new second filter operator of the filtered column.
+    /// </summary>
+    public FilterOperator SecondFilterOperator { get; internal set; }
+
+    /// <summary>
+    /// Gets the new logical filter operator of the filtered column.
+    /// </summary>
+    public LogicalFilterOperator LogicalFilterOperator { get; internal set; }
+}
+

Radzen.Blazor/DataGridColumnGroupEventArgs.cs

@@ -0,0 +1,21 @@
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="RadzenDataGrid{TItem}.Group" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridColumnGroupEventArgs<T>
+{
+    /// <summary>
+    /// Gets the grouped RadzenDataGridColumn.
+    /// </summary>
+    public RadzenDataGridColumn<T> Column { get; internal set; }
+
+    /// <summary>
+    /// Gets the group descriptor.
+    /// </summary>
+    public GroupDescriptor GroupDescriptor { get; internal set; }
+}
+

Radzen.Blazor/DataGridColumnReorderedEventArgs.cs

@@ -0,0 +1,26 @@
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="RadzenDataGrid{TItem}.ColumnReordered" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridColumnReorderedEventArgs<T>
+{
+    /// <summary>
+    /// Gets the reordered RadzenDataGridColumn.
+    /// </summary>
+    public RadzenDataGridColumn<T> Column { get; internal set; }
+
+    /// <summary>
+    /// Gets the old index of the column.
+    /// </summary>
+    public int OldIndex { get; internal set; }
+
+    /// <summary>
+    /// Gets the new index of the column.
+    /// </summary>
+    public int NewIndex { get; internal set; }
+}
+

Radzen.Blazor/DataGridColumnReorderingEventArgs.cs

@@ -0,0 +1,27 @@
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="RadzenDataGrid{TItem}.ColumnReordering" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridColumnReorderingEventArgs<T>
+{
+    /// <summary>
+    /// Gets the reordered RadzenDataGridColumn.
+    /// </summary>
+    public RadzenDataGridColumn<T> Column { get; internal set; }
+
+    /// <summary>
+    /// Gets the reordered to RadzenDataGridColumn.
+    /// </summary>
+    public RadzenDataGridColumn<T> ToColumn { get; internal set; }
+
+    /// <summary>
+    /// Gets or sets a value which will cancel the event.
+    /// </summary>
+    /// <value><c>true</c> to cancel the event; otherwise, <c>false</c>.</value>
+    public bool Cancel { get; set; }
+}
+

Radzen.Blazor/DataGridColumnResizedEventArgs.cs

@@ -0,0 +1,21 @@
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="RadzenDataGrid{TItem}.ColumnResized" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridColumnResizedEventArgs<T>
+{
+    /// <summary>
+    /// Gets the resized RadzenDataGridColumn.
+    /// </summary>
+    public RadzenDataGridColumn<T> Column { get; internal set; }
+
+    /// <summary>
+    /// Gets the new width of the resized column.
+    /// </summary>
+    public double Width { get; internal set; }
+}
+

Radzen.Blazor/DataGridColumnSettings.cs

@@ -0,0 +1,81 @@
+namespace Radzen;
+
+/// <summary>
+/// DataGrid column settings class used to Save/Load settings.
+/// </summary>
+public class DataGridColumnSettings
+{
+    /// <summary>
+    /// Property.
+    /// </summary>
+    public string UniqueID { get; set; }
+
+    /// <summary>
+    /// Property.
+    /// </summary>
+    public string Property { get; set; }
+
+    /// <summary>
+    /// Visible.
+    /// </summary>
+    public bool Visible { get; set; }
+
+    /// <summary>
+    /// Width.
+    /// </summary>
+    public string Width { get; set; }
+
+    /// <summary>
+    /// OrderIndex.
+    /// </summary>
+    public int? OrderIndex { get; set; }
+
+    /// <summary>
+    /// SortOrder.
+    /// </summary>
+    public SortOrder? SortOrder { get; set; }
+
+    /// <summary>
+    /// SortIndex.
+    /// </summary>
+    public int? SortIndex { get; set; }
+
+    /// <summary>
+    /// FilterValue.
+    /// </summary>
+    public object FilterValue { get; set; }
+
+    /// <summary>
+    /// FilterOperator.
+    /// </summary>
+    public FilterOperator FilterOperator { get; set; }
+
+    /// <summary>
+    /// SecondFilterValue.
+    /// </summary>
+    public object SecondFilterValue { get; set; }
+
+    /// <summary>
+    /// SecondFilterOperator.
+    /// </summary>
+    public FilterOperator SecondFilterOperator { get; set; }
+
+    /// <summary>
+    /// LogicalFilterOperator.
+    /// </summary>
+    public LogicalFilterOperator LogicalFilterOperator { get; set; }
+
+    /// <summary>
+    /// CustomFilterExpression.
+    /// </summary>
+    public string CustomFilterExpression { get; set; }
+
+    /// <summary>
+    /// Gets or sets the mode that determines whether the filter applies to any or all items in a collection.
+    /// </summary>
+    /// <value>
+    /// A <see cref="CollectionFilterMode"/> value indicating whether the filter is satisfied by any or all items.
+    /// </value>
+    public CollectionFilterMode CollectionFilterMode { get; set; }
+}
+

Radzen.Blazor/DataGridColumnSortEventArgs.cs

@@ -0,0 +1,21 @@
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="RadzenDataGrid{TItem}.Sort" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridColumnSortEventArgs<T>
+{
+    /// <summary>
+    /// Gets the sorted RadzenDataGridColumn.
+    /// </summary>
+    public RadzenDataGridColumn<T> Column { get; internal set; }
+
+    /// <summary>
+    /// Gets the new sort order of the sorted column.
+    /// </summary>
+    public SortOrder? SortOrder { get; internal set; }
+}
+

Radzen.Blazor/DataGridEditMode.cs

@@ -0,0 +1,18 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the inline edit mode behavior of <see cref="Radzen.Blazor.RadzenDataGrid{TItem}" />.
+/// </summary>
+public enum DataGridEditMode
+{
+    /// <summary>
+    /// The user can edit only one row at a time. Editing a different row cancels edit mode for the last edited row.
+    /// </summary>
+    Single,
+
+    /// <summary>
+    /// The user can edit multiple rows.
+    /// </summary>
+    Multiple
+}
+

Radzen.Blazor/DataGridExpandMode.cs

@@ -0,0 +1,18 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the expand behavior of <see cref="Radzen.Blazor.RadzenDataGrid{TItem}" />.
+/// </summary>
+public enum DataGridExpandMode
+{
+    /// <summary>
+    /// The user can expand only one row at a time. Expanding a different row collapses the last expanded row.
+    /// </summary>
+    Single,
+
+    /// <summary>
+    /// The user can expand multiple rows.
+    /// </summary>
+    Multiple
+}
+

Radzen.Blazor/DataGridGridLines.cs

@@ -0,0 +1,33 @@
+namespace Radzen;
+
+/// <summary>
+/// Specifies the grid lines of <see cref="Radzen.Blazor.RadzenDataGrid{TItem}" />.
+/// </summary>
+public enum DataGridGridLines
+{
+    /// <summary>
+    /// Theme default.
+    /// </summary>
+    Default,
+
+    /// <summary>
+    /// Both horizontal and vertical grid lines.
+    /// </summary>
+    Both,
+
+    /// <summary>
+    /// No grid lines.
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Horizontal grid lines.
+    /// </summary>
+    Horizontal,
+
+    /// <summary>
+    /// Vertical grid lines.
+    /// </summary>
+    Vertical
+}
+

Radzen.Blazor/DataGridLoadChildDataEventArgs.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="Radzen.Blazor.RadzenDataGrid{TItem}.LoadChildData" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridLoadChildDataEventArgs<T>
+{
+    /// <summary>
+    /// Gets or sets the data.
+    /// </summary>
+    /// <value>The data.</value>
+    public IEnumerable<T> Data { get; set; }
+
+    /// <summary>
+    /// Gets the item.
+    /// </summary>
+    /// <value>The item.</value>
+    public T Item { get; internal set; }
+}
+

Radzen.Blazor/DataGridLoadColumnFilterDataEventArgs.cs

@@ -0,0 +1,53 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="Radzen.Blazor.RadzenDataGrid{TItem}.LoadColumnFilterData" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridLoadColumnFilterDataEventArgs<T>
+{
+    /// <summary>
+    /// Gets or sets the data.
+    /// </summary>
+    /// <value>The data.</value>
+    public IEnumerable Data { get; set; }
+
+    /// <summary>
+    /// Gets or sets the total data count.
+    /// </summary>
+    /// <value>The total data count.</value>
+    public int Count { get; set; }
+
+    /// <summary>
+    /// Gets how many items to skip. Related to paging and the current page. Usually used with the <see cref="Enumerable.Skip{TSource}(IEnumerable{TSource}, int)"/> LINQ method.
+    /// </summary>
+    public int? Skip { get; set; }
+
+    /// <summary>
+    /// Gets how many items to take. Related to paging and the current page size. Usually used with the <see cref="Enumerable.Take{TSource}(IEnumerable{TSource}, int)"/> LINQ method.
+    /// </summary>
+    /// <value>The top.</value>
+    public int? Top { get; set; }
+
+    /// <summary>
+    /// Gets the filter expression as a string.
+    /// </summary>
+    /// <value>The filter.</value>
+    public string Filter { get; internal set; }
+
+    /// <summary>
+    /// Gets or sets filter property used to limit and distinct values, if not set, args.Data are used as values.
+    /// </summary>
+    /// <value>The filter property.</value>
+    public string Property { get; set; }
+
+    /// <summary>
+    /// Gets the RadzenDataGridColumn.
+    /// </summary>
+    public Radzen.Blazor.RadzenDataGridColumn<T> Column { get; internal set; }
+}
+

Radzen.Blazor/DataGridLoadSettingsEventArgs.cs

@@ -0,0 +1,13 @@
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="Radzen.Blazor.RadzenDataGrid{TItem}.LoadSettings" /> event that is being raised.
+/// </summary>
+public class DataGridLoadSettingsEventArgs
+{
+    /// <summary>
+    /// Gets or sets the settings.
+    /// </summary>
+    public DataGridSettings Settings { get; set; }
+}
+

Radzen.Blazor/DataGridPickedColumnsChangedEventArgs.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using Radzen.Blazor;
+
+namespace Radzen;
+
+/// <summary>
+/// Supplies information about a <see cref="RadzenDataGrid{TItem}.PickedColumnsChanged" /> event that is being raised.
+/// </summary>
+/// <typeparam name="T">The data item type.</typeparam>
+public class DataGridPickedColumnsChangedEventArgs<T>
+{
+    /// <summary>
+    /// Gets the picked columns.
+    /// </summary>
+    public IEnumerable<RadzenDataGridColumn<T>> Columns { get; internal set; }
+}
+