diff --git a/README.md b/README.md
index e9c59c8..3063f50 100644
--- a/README.md
+++ b/README.md
@@ -129,20 +129,20 @@ public class MyViewModel : ViewModelBase
 ```
 In this example, if the `Counter` property hasn’t been set before, the Get(10) will return 10 as the default value.
 
-### Asynchronous FluentCommand (`AsyncCommand`)
-The AsyncCommand in the MVVMFluent library is designed to simplify asynchronous command execution with built-in support for cancellation, progress reporting, and exception handling. It allows you to execute long-running tasks without blocking the UI thread, while maintaining full control over the command's lifecycle.
+### Asynchronous FluentCommand (`AsyncFluentCommand`)
+The AsyncFluentCommand in the MVVMFluent library is designed to simplify asynchronous command execution with built-in support for cancellation, progress reporting, and exception handling. It allows you to execute long-running tasks without blocking the UI thread, while maintaining full control over the command's lifecycle.
 
 **Key Features:**
 - **Cancellation Support:** The `CancelCommand` property allows users to stop an ongoing asynchronous operation, making it ideal for tasks that may take a significant amount of time or need to be interrupted.
 - **Execution State Tracking:** The command exposes an `IsRunning` property to indicate whether the command is currently executing, which can be bound to UI elements like progress bars or buttons to reflect the task status dynamically.
 - **Progress Reporting:** The `Progress` property enables reporting task completion status, which can be updated via the ReportProgress method. This is especially useful when performing iterative tasks or tasks with multiple stages.
-- **Fluent Configuration:** Similar to the rest of the MVVMFluent library, the `AsyncCommand` can be configured fluently, allowing you to chain conditions (`If()`), exception handling (`Handle()`), and cancellation logic seamlessly.
+- **Fluent Configuration:** Similar to the rest of the MVVMFluent library, the `AsyncFluentCommand` can be configured fluently, allowing you to chain conditions (`If()`), exception handling (`Handle()`), and cancellation logic seamlessly.
 
 Example Usage
 In your view model:
 
 ```csharp
-public AsyncCommand LoadCommand => 
+public AsyncFluentCommand LoadCommand => 
                  Do(LoadData)
                 .If(() => CanLoad)
                 .Handle(ex => HandleError(ex));
@@ -173,10 +173,10 @@ In XAML:
 <Button Content="Cancel" FluentCommand="{Binding LoadCommand.CancelCommand}" />
 ```
 
-This example demonstrates how AsyncCommand integrates with both your view model and XAML, providing a responsive and user-friendly interface for long-running or cancellable operations.
+This example demonstrates how AsyncFluentCommand integrates with both your view model and XAML, providing a responsive and user-friendly interface for long-running or cancellable operations.
 
-### Asynchronous FluentCommand with Parameter (`AsyncCommand<T>`)
-The `AsyncCommand<T>` extends the functionality of AsyncCommand by allowing you to pass a parameter of type `T` to the asynchronous execution logic. This makes it ideal for scenarios where the command needs to act on dynamic data or context-specific parameters. Like `AsyncCommand`, it supports cancellation, progress reporting, and exception handling, while maintaining the same fluent API for configuration.
+### Asynchronous FluentCommand with Parameter (`AsyncFluentCommand<T>`)
+The `AsyncFluentCommand<T>` extends the functionality of AsyncFluentCommand by allowing you to pass a parameter of type `T` to the asynchronous execution logic. This makes it ideal for scenarios where the command needs to act on dynamic data or context-specific parameters. Like `AsyncFluentCommand`, it supports cancellation, progress reporting, and exception handling, while maintaining the same fluent API for configuration.
 
 ### Validation Fluent Setter (`ValidationFluentSetter<TValue>`)
 The `ValidationFluentSetter<TValue>` class in the `MVVMFluent.WPF` library provides a flexible framework for implementing validation in your MVVM applications. It supports three distinct validation methods: Built-in Validation Rules allow the use of WPF’s standard validation rules, which can be added to the setter using the `Validate(params ValidationRule[] rules)` method. For example:
@@ -356,7 +356,7 @@ namespace MVVMFluent.Demo
             return !string.IsNullOrWhiteSpace(value);
         }
 
-        public AsyncCommand LoadCommand =>
+        public AsyncFluentCommand LoadCommand =>
                 Do(LoadData)
                 .If(() => Comments?.Contains("Load") == true)
                 .Handle(HandleError);
diff --git a/src/MVVMFluent.Demo/MainViewModel.cs b/src/MVVMFluent.Demo/MainViewModel.cs
index 7b19451..e7210bb 100644
--- a/src/MVVMFluent.Demo/MainViewModel.cs
+++ b/src/MVVMFluent.Demo/MainViewModel.cs
@@ -15,7 +15,7 @@ public MainViewModel()
     public string? Input
     {
         get => Get<string?>();
-        set => When(value).Required().Notify(AsyncCommand, OkCommand).Set();
+        set => When(value).Required().Notify(AsyncFluentCommand, OkCommand).Set();
     }
 
     public FluentCommand OkCommand => Do(() => ShowDialog(Input)).IfValid(nameof(Input));
@@ -27,7 +27,7 @@ private bool CanExecute()
 
     public bool ThrowException { get => Get(false); set => Set(value); }
 
-    public AsyncCommand AsyncCommand => Do(ShowDialogAsync).If(CanExecute).Handle(HandleException).ConfigureAwait(false);
+    public AsyncFluentCommand AsyncFluentCommand => Do(ShowDialogAsync).If(CanExecute).Handle(HandleException).ConfigureAwait(false);
 
     private void HandleException(Exception exception)
     {
@@ -45,9 +45,9 @@ private async Task ShowDialogAsync(CancellationToken cancellationToken)
                 throw new TaskCanceledException();
 
             await Task.Delay(50, cancellationToken);
-            AsyncCommand.ReportProgress(i+1, 100);
+            AsyncFluentCommand.ReportProgress(i+1, 100);
 
-            if (AsyncCommand.Progress == 50 && ThrowException)
+            if (AsyncFluentCommand.Progress == 50 && ThrowException)
                 throw new Exception("Something went wrong");
 
         }
diff --git a/src/MVVMFluent.Demo/MainWindow.xaml b/src/MVVMFluent.Demo/MainWindow.xaml
index b06bcaa..d43a702 100644
--- a/src/MVVMFluent.Demo/MainWindow.xaml
+++ b/src/MVVMFluent.Demo/MainWindow.xaml
@@ -40,11 +40,11 @@
         </TextBox>
 
         <ProgressBar Grid.Row="2" VerticalAlignment="Center" Padding="10" Margin="10"
-                     Value="{Binding AsyncCommand.Progress}" Minimum="0" Maximum="100" Height="10">
+                     Value="{Binding AsyncFluentCommand.Progress}" Minimum="0" Maximum="100" Height="10">
             <ProgressBar.Style>
                 <Style TargetType="ProgressBar">
                     <Style.Triggers>
-                        <DataTrigger Binding="{Binding AsyncCommand.IsRunning}" Value="False">
+                        <DataTrigger Binding="{Binding AsyncFluentCommand.IsRunning}" Value="False">
                             <Setter Property="Visibility" Value="Collapsed" />
                         </DataTrigger>
                     </Style.Triggers>
@@ -59,11 +59,11 @@
 
             <Button DockPanel.Dock="Right" Padding="15,0" Margin="10"
                     Content="Async"
-                    Command="{Binding AsyncCommand}" />
+                    Command="{Binding AsyncFluentCommand}" />
 
             <Button DockPanel.Dock="Right" Padding="15,0" Margin="10"
                     Content="Cancel"
-                    Command="{Binding AsyncCommand.CancelCommand}" />
+                    Command="{Binding AsyncFluentCommand.CancelCommand}" />
 
             <CheckBox DockPanel.Dock="Left" Padding="10" Margin="10,5"
                       VerticalAlignment="Center" VerticalContentAlignment="Center"
diff --git a/src/MVVMFluent.WPF/CommandValidationExtensions.cs b/src/MVVMFluent.WPF/CommandValidationExtensions.cs
index 7540718..d2dd25c 100644
--- a/src/MVVMFluent.WPF/CommandValidationExtensions.cs
+++ b/src/MVVMFluent.WPF/CommandValidationExtensions.cs
@@ -46,7 +46,7 @@ public static FluentCommand<T> IfValid<T>(this FluentCommand<T> command, params
         /// <param name="propertyName">The name of the property to check for errors.</param>
         /// <returns>The command with the condition added.</returns>
         /// <exception cref="global::System.ArgumentNullException">Thrown when the property name is null or empty.</exception>
-        public static AsyncCommand IfValid(this AsyncCommand command, params string[] propertyName)
+        public static AsyncFluentCommand IfValid(this AsyncFluentCommand command, params string[] propertyName)
         {
             if (command.IsBuilt)
                 return command;
@@ -65,7 +65,7 @@ public static AsyncCommand IfValid(this AsyncCommand command, params string[] pr
         /// <param name="propertyName">The name of the property to check for errors.</param>
         /// <returns>The command with the condition added.</returns>
         /// <exception cref="global::System.ArgumentNullException">Thrown when the property name is null or empty.</exception>
-        public static AsyncCommand<T> IfValid<T>(this AsyncCommand<T> command, params string[] propertyName)
+        public static AsyncFluentCommand<T> IfValid<T>(this AsyncFluentCommand<T> command, params string[] propertyName)
         {
             if (command.IsBuilt)
                 return command;
diff --git a/src/MVVMFluent/AsyncCommand.cs b/src/MVVMFluent/AsyncFluentCommand.cs
similarity index 87%
rename from src/MVVMFluent/AsyncCommand.cs
rename to src/MVVMFluent/AsyncFluentCommand.cs
index cfaf42b..c83a516 100644
--- a/src/MVVMFluent/AsyncCommand.cs
+++ b/src/MVVMFluent/AsyncFluentCommand.cs
@@ -56,18 +56,18 @@ public interface IAsyncFluentCommand : IFluentCommand, global::System.IDisposabl
     /// Represents an asynchronous command that supports cancellation and tracks execution state.
     /// <example>
     /// <code lang="csharp">
-    /// public AsyncCommand OkCommand => Do(async () => await Task.Delay(1000)).If(() => CanOk).Handle(ex => MessageBox.Show(ex.Message)).ConfigureAwait(false);
+    /// public AsyncFluentCommand OkCommand => Do(async () => await Task.Delay(1000)).If(() => CanOk).Handle(ex => MessageBox.Show(ex.Message)).ConfigureAwait(false);
     /// 
     /// public bool CanOk { get => Get(true); set => Set(value); }
     /// </code>
     /// <code lang="xaml">
-    /// &lt;Button Content=&quot;Run&quot; FluentCommand=&quot;{Binding AsyncCommand}&quot; /&gt;
-    /// &lt;ProgressBar Visibility = &quot;{Binding AsyncCommand.IsRunning, Converter={StaticResource BoolToVisibilityConverter}}&quot; /&gt;
-    /// &lt;Button Content=&quot;Cancel&quot; FluentCommand=&quot;{Binding AsyncCommand.CancelCommand}&quot; /&gt;
+    /// &lt;Button Content=&quot;Run&quot; FluentCommand=&quot;{Binding AsyncFluentCommand}&quot; /&gt;
+    /// &lt;ProgressBar Visibility = &quot;{Binding AsyncFluentCommand.IsRunning, Converter={StaticResource BoolToVisibilityConverter}}&quot; /&gt;
+    /// &lt;Button Content=&quot;Cancel&quot; FluentCommand=&quot;{Binding AsyncFluentCommand.CancelCommand}&quot; /&gt;
     /// </code>
     /// </example>
     /// </summary>
-    public class AsyncCommand : IAsyncFluentCommand, global::System.ComponentModel.INotifyPropertyChanged, global::System.IDisposable
+    public class AsyncFluentCommand : IAsyncFluentCommand, global::System.ComponentModel.INotifyPropertyChanged, global::System.IDisposable
     {
         private global::System.Func<object?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task>? _execute;
         private global::System.Func<object?, bool>? _canExecute;
@@ -236,8 +236,8 @@ public void Cancel()
         /// Creates an asynchronous command with the specified execute action.
         /// </summary>
         /// <param name="execute">The action to execute asynchronously.</param>
-        /// <returns>An instance of <see cref="AsyncCommand"/>.</returns>
-        public static AsyncCommand Do(global::System.Func<global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
+        /// <returns>An instance of <see cref="AsyncFluentCommand"/>.</returns>
+        public static AsyncFluentCommand Do(global::System.Func<global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
         {
             return Do((_, _) => execute(), owner);
         }
@@ -246,10 +246,10 @@ public static AsyncCommand Do(global::System.Func<global::System.Threading.Tasks
         /// Creates an asynchronous command with the specified execute action.
         /// </summary>
         /// <param name="execute">The action to execute asynchronously.</param>
-        /// <returns>An instance of <see cref="AsyncCommand"/>.</returns>
-        public static AsyncCommand Do(global::System.Func<object?, global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
+        /// <returns>An instance of <see cref="AsyncFluentCommand"/>.</returns>
+        public static AsyncFluentCommand Do(global::System.Func<object?, global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
         {
-            var command = new AsyncCommand
+            var command = new AsyncFluentCommand
             {
                 Owner = owner
             };
@@ -261,10 +261,10 @@ public static AsyncCommand Do(global::System.Func<object?, global::System.Thread
         /// Creates an asynchronous command with the specified execute action.
         /// </summary>
         /// <param name="execute">The action to execute asynchronously.</param>
-        /// <returns>An instance of <see cref="AsyncCommand"/>.</returns>
-        public static AsyncCommand Do(global::System.Func<object?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
+        /// <returns>An instance of <see cref="AsyncFluentCommand"/>.</returns>
+        public static AsyncFluentCommand Do(global::System.Func<object?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
         {
-            var command = new AsyncCommand
+            var command = new AsyncFluentCommand
             {
                 Owner = owner
             };
@@ -277,7 +277,7 @@ public static AsyncCommand Do(global::System.Func<object?, global::System.Thread
         /// </summary>
         /// <param name="canExecute">The condition function.</param>
         /// <returns>The updated command instance.</returns>
-        public AsyncCommand If(global::System.Func<bool> canExecute)
+        public AsyncFluentCommand If(global::System.Func<bool> canExecute)
         {
             return If(_ => canExecute());
         }
@@ -287,7 +287,7 @@ public AsyncCommand If(global::System.Func<bool> canExecute)
         /// </summary>
         /// <param name="canExecute">The condition function.</param>
         /// <returns>The updated command instance.</returns>
-        public AsyncCommand If(global::System.Func<object?, bool> canExecute)
+        public AsyncFluentCommand If(global::System.Func<object?, bool> canExecute)
         {
             if (IsBuilt)
                 return this;
@@ -301,7 +301,7 @@ public AsyncCommand If(global::System.Func<object?, bool> canExecute)
         /// </summary>
         /// <param name="handle">The action to handle exceptions.</param>
         /// <returns>The updated command instance.</returns>
-        public AsyncCommand Handle(global::System.Action<global::System.Exception> handle)
+        public AsyncFluentCommand Handle(global::System.Action<global::System.Exception> handle)
         {
             if (IsBuilt)
                 return this;
@@ -315,7 +315,7 @@ public AsyncCommand Handle(global::System.Action<global::System.Exception> handl
         /// </summary>
         /// <param name="continueOnCapturedContext">Whether to continue on captured context.</param>
         /// <returns>The updated command instance.</returns>
-        public AsyncCommand ConfigureAwait(bool continueOnCapturedContext)
+        public AsyncFluentCommand ConfigureAwait(bool continueOnCapturedContext)
         {
             if (IsBuilt)
                 return this;
@@ -377,9 +377,9 @@ protected virtual void Dispose(bool disposing)
         }
 
         /// <summary>
-        /// Finalizer for the <see cref="AsyncCommand"/> class.
+        /// Finalizer for the <see cref="AsyncFluentCommand"/> class.
         /// </summary>
-        ~AsyncCommand()
+        ~AsyncFluentCommand()
         {
             Dispose(false);
         }
@@ -389,7 +389,7 @@ protected virtual void Dispose(bool disposing)
     /// Represents an asynchronous command that supports cancellation and tracks execution state, with a generic parameter.
     /// <example>
     /// <code lang="csharp">
-    /// public AsyncCommand OkCommand => Do&lt;string&gt;(Ok).If(() => CanOk).Handle(ex => MessageBox.Show(ex.Message)).ConfigureAwait(true);
+    /// public AsyncFluentCommand OkCommand => Do&lt;string&gt;(Ok).If(() => CanOk).Handle(ex => MessageBox.Show(ex.Message)).ConfigureAwait(true);
     /// 
     /// public async Task Ok(string input)
     /// {
@@ -400,13 +400,13 @@ protected virtual void Dispose(bool disposing)
     /// public bool CanOk { get => Get(true); set => Set(value); }
     /// </code>
     /// <code lang="xaml">
-    /// &lt;Button Content=&quot;Run&quot; FluentCommand=&quot;{Binding AsyncCommand}&quot; /&gt;
-    /// &lt;ProgressBar Visibility = &quot;{Binding AsyncCommand.IsRunning, Converter={StaticResource BoolToVisibilityConverter}}&quot; /&gt;
-    /// &lt;Button Content=&quot;Cancel&quot; FluentCommand=&quot;{Binding AsyncCommand.CancelCommand}&quot; /&gt;
+    /// &lt;Button Content=&quot;Run&quot; FluentCommand=&quot;{Binding AsyncFluentCommand}&quot; /&gt;
+    /// &lt;ProgressBar Visibility = &quot;{Binding AsyncFluentCommand.IsRunning, Converter={StaticResource BoolToVisibilityConverter}}&quot; /&gt;
+    /// &lt;Button Content=&quot;Cancel&quot; FluentCommand=&quot;{Binding AsyncFluentCommand.CancelCommand}&quot; /&gt;
     /// </code>
     /// </example>
     /// </summary>
-    public class AsyncCommand<T> : IAsyncFluentCommand, global::System.ComponentModel.INotifyPropertyChanged, global::System.IDisposable
+    public class AsyncFluentCommand<T> : IAsyncFluentCommand, global::System.ComponentModel.INotifyPropertyChanged, global::System.IDisposable
     {
         private global::System.Func<T?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task>? _execute;
         private global::System.Func<T?, bool>? _canExecute;
@@ -581,10 +581,10 @@ public void Cancel()
         /// Creates an asynchronous command with the specified execute action.
         /// </summary>
         /// <param name="execute">The action to execute asynchronously.</param>
-        /// <returns>An instance of <see cref="AsyncCommand{T}"/>.</returns>
-        public static AsyncCommand<T> Do(global::System.Func<T?, global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
+        /// <returns>An instance of <see cref="AsyncFluentCommand{T}"/>.</returns>
+        public static AsyncFluentCommand<T> Do(global::System.Func<T?, global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
         {
-            var command = new AsyncCommand<T>
+            var command = new AsyncFluentCommand<T>
             {
                 Owner = owner
             };
@@ -596,10 +596,10 @@ public static AsyncCommand<T> Do(global::System.Func<T?, global::System.Threadin
         /// Creates an asynchronous command with the specified execute action.
         /// </summary>
         /// <param name="execute">The action to execute asynchronously.</param>
-        /// <returns>An instance of <see cref="AsyncCommand{T}"/>.</returns>
-        public static AsyncCommand<T> Do(global::System.Func<T?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
+        /// <returns>An instance of <see cref="AsyncFluentCommand{T}"/>.</returns>
+        public static AsyncFluentCommand<T> Do(global::System.Func<T?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, IFluentSetterViewModel? owner)
         {
-            var command = new AsyncCommand<T>
+            var command = new AsyncFluentCommand<T>
             {
                 Owner = owner
             };
@@ -612,7 +612,7 @@ public static AsyncCommand<T> Do(global::System.Func<T?, global::System.Threadin
         /// </summary>
         /// <param name="canExecute">The condition function.</param>
         /// <returns>The updated command instance.</returns>
-        public AsyncCommand<T> If(global::System.Func<T?, bool> canExecute)
+        public AsyncFluentCommand<T> If(global::System.Func<T?, bool> canExecute)
         {
             if (IsBuilt)
                 return this;
@@ -626,7 +626,7 @@ public AsyncCommand<T> If(global::System.Func<T?, bool> canExecute)
         /// </summary>
         /// <param name="handle">The action to handle exceptions.</param>
         /// <returns>The updated command instance.</returns>
-        public AsyncCommand<T> Handle(global::System.Action<global::System.Exception> handle)
+        public AsyncFluentCommand<T> Handle(global::System.Action<global::System.Exception> handle)
         {
             if (IsBuilt)
                 return this;
@@ -640,7 +640,7 @@ public AsyncCommand<T> Handle(global::System.Action<global::System.Exception> ha
         /// </summary>
         /// <param name="continueOnCapturedContext">Whether to continue on captured context.</param>
         /// <returns>The updated command instance.</returns>
-        public AsyncCommand<T> ConfigureAwait(bool continueOnCapturedContext)
+        public AsyncFluentCommand<T> ConfigureAwait(bool continueOnCapturedContext)
         {
             if (IsBuilt)
                 return this;
@@ -701,9 +701,9 @@ protected virtual void Dispose(bool disposing)
         }
 
         /// <summary>
-        /// Finalizer for the <see cref="AsyncCommand"/> class.
+        /// Finalizer for the <see cref="AsyncFluentCommand"/> class.
         /// </summary>
-        ~AsyncCommand()
+        ~AsyncFluentCommand()
         {
             Dispose(false);
         }
diff --git a/src/MVVMFluent/FluentSetterViewModelBase.cs b/src/MVVMFluent/FluentSetterViewModelBase.cs
index 1e734e6..ddfce04 100644
--- a/src/MVVMFluent/FluentSetterViewModelBase.cs
+++ b/src/MVVMFluent/FluentSetterViewModelBase.cs
@@ -188,23 +188,23 @@ protected FluentCommand Do(global::System.Action<object?> execute, [global::Syst
         /// Creates an asynchronous command that supports cancellation and tracks execution state.
         /// <example>
         /// <code lang="csharp">
-        /// public AsyncCommand OkCommand => Do(async () => await Task.Delay(1000)).If(() => CanOk).Handle(ex => MessageBox.Show(ex.Message)).ConfigureAwait(false);
+        /// public AsyncFluentCommand OkCommand => Do(async () => await Task.Delay(1000)).If(() => CanOk).Handle(ex => MessageBox.Show(ex.Message)).ConfigureAwait(false);
         /// 
         /// public bool CanOk { get => Get(true); set => Set(value); }
         /// </code>
         /// <code lang="xaml">
-        /// &lt;Button Content=&quot;Run&quot; FluentCommand=&quot;{Binding AsyncCommand}&quot; /&gt;
-        /// &lt;ProgressBar Visibility = &quot;{Binding AsyncCommand.IsRunning, Converter={StaticResource BoolToVisibilityConverter}}&quot; /&gt;
-        /// &lt;Button Content=&quot;Cancel&quot; FluentCommand=&quot;{Binding AsyncCommand.CancelCommand}&quot; /&gt;
+        /// &lt;Button Content=&quot;Run&quot; FluentCommand=&quot;{Binding AsyncFluentCommand}&quot; /&gt;
+        /// &lt;ProgressBar Visibility = &quot;{Binding AsyncFluentCommand.IsRunning, Converter={StaticResource BoolToVisibilityConverter}}&quot; /&gt;
+        /// &lt;Button Content=&quot;Cancel&quot; FluentCommand=&quot;{Binding AsyncFluentCommand.CancelCommand}&quot; /&gt;
         /// </code>
         /// </example>
         /// </summary>
         /// <param name="execute">The action to execute.</param>
         /// <param name="propertyName">The name of the property associated with the command.</param>
-        /// <returns>A new <see cref="AsyncCommand"/> instance.</returns>
+        /// <returns>A new <see cref="AsyncFluentCommand"/> instance.</returns>
         /// <exception cref="global::System.ArgumentNullException">Thrown when the property name is null or empty.</exception>
         /// <exception cref="global::System.ArgumentException">Thrown when the property name is .ctor.</exception>
-        protected AsyncCommand Do(global::System.Func<global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
+        protected AsyncFluentCommand Do(global::System.Func<global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
         {
             return Do((object? _) => execute(), propertyName);
         }
@@ -213,7 +213,7 @@ protected AsyncCommand Do(global::System.Func<global::System.Threading.Tasks.Tas
         /// Creates an asynchronous command that passes a cancellation token to the method.
         /// <example>
         /// <code lang="csharp">
-        /// public AsyncCommand OkCommand => Do(Ok);
+        /// public AsyncFluentCommand OkCommand => Do(Ok);
         /// 
         /// private Task Ok(CancellationToken cancellationToken) { }
         /// </code>
@@ -221,15 +221,15 @@ protected AsyncCommand Do(global::System.Func<global::System.Threading.Tasks.Tas
         /// </summary>
         /// <param name="execute">The action to execute.</param>
         /// <param name="propertyName">The name of the property associated with the command.</param>
-        /// <returns>A new <see cref="AsyncCommand"/> instance.</returns>
+        /// <returns>A new <see cref="AsyncFluentCommand"/> instance.</returns>
         /// <exception cref="global::System.ArgumentNullException">Thrown when the property name is null or empty.</exception>
         /// <exception cref="global::System.ArgumentException">Thrown when the property name is .ctor.</exception>
-        protected AsyncCommand Do(global::System.Func<global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
+        protected AsyncFluentCommand Do(global::System.Func<global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
         {
             return Do((_,ct) => execute(ct), propertyName);
         }
 
-        protected AsyncCommand<TValue> Do<TValue>(global::System.Func<global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
+        protected AsyncFluentCommand<TValue> Do<TValue>(global::System.Func<global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
         {
             return Do<TValue>((_,ct) => execute(ct), propertyName);
         }
@@ -239,21 +239,21 @@ protected AsyncCommand<TValue> Do<TValue>(global::System.Func<global::System.Thr
         /// <example>
         /// <code lang="csharp">
         /// // Short command
-        /// public AsyncCommand OkCommand => Do(async () => await Task.Delay(1000)).If(() => CanOk);
+        /// public AsyncFluentCommand OkCommand => Do(async () => await Task.Delay(1000)).If(() => CanOk);
         /// </code>
         /// <code lang="csharp">
         /// // FluentCommand with all options
-        /// public AsyncCommand&lt;string&gt; OkCommand => Do&lt;string&gt;(str => Task.Delay(1000).ContinueWith(_ => MessageBox.Show(str))).If(str => CanOk(str)).Handle(ex => MessageBox.Show(ex.Message)).ConfigureAwait(false);
+        /// public AsyncFluentCommand&lt;string&gt; OkCommand => Do&lt;string&gt;(str => Task.Delay(1000).ContinueWith(_ => MessageBox.Show(str))).If(str => CanOk(str)).Handle(ex => MessageBox.Show(ex.Message)).ConfigureAwait(false);
         /// </code>
         /// </example>
         /// </summary>
         /// <typeparam name="TValue">The type of the parameter for the command.</typeparam>
         /// <param name="execute">The action to execute.</param>
         /// <param name="propertyName">The name of the property associated with the command.</param>
-        /// <returns>A new <see cref="AsyncCommand{TValue}"/> instance.</returns>
+        /// <returns>A new <see cref="AsyncFluentCommand{TValue}"/> instance.</returns>
         /// <exception cref="global::System.ArgumentNullException">Thrown when the property name is null or empty.</exception>
         /// <exception cref="global::System.ArgumentException">Thrown when the property name is .ctor.</exception>
-        protected AsyncCommand<TValue> Do<TValue>(global::System.Func<TValue?, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
+        protected AsyncFluentCommand<TValue> Do<TValue>(global::System.Func<TValue?, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
         {
             return Do<TValue>((para, ct) => execute(para), propertyName);
         }
@@ -262,7 +262,7 @@ protected AsyncCommand<TValue> Do<TValue>(global::System.Func<TValue?, global::S
         /// Creates an asynchronous command that passes a cancellation token to the method.
         /// <example>
         /// <code lang="csharp">
-        /// public AsyncCommand&lt;string&gt; OkCommand => Do&lt;string?&gt;(Ok);
+        /// public AsyncFluentCommand&lt;string&gt; OkCommand => Do&lt;string?&gt;(Ok);
         /// 
         /// private Task Ok(string? str, CancellationToken cancellationToken) { }
         /// </code>
@@ -271,10 +271,10 @@ protected AsyncCommand<TValue> Do<TValue>(global::System.Func<TValue?, global::S
         /// <typeparam name="TValue">The type of the parameter for the command.</typeparam>
         /// <param name="execute">The action to execute.</param>
         /// <param name="propertyName">The name of the property associated with the command.</param>
-        /// <returns>A new <see cref="AsyncCommand{TValue}"/> instance.</returns>
+        /// <returns>A new <see cref="AsyncFluentCommand{TValue}"/> instance.</returns>
         /// <exception cref="global::System.ArgumentNullException">Thrown when the property name is null or empty.</exception>
         /// <exception cref="global::System.ArgumentException">Thrown when the property name is .ctor.</exception>
-        protected AsyncCommand<TValue> Do<TValue>(global::System.Func<TValue?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
+        protected AsyncFluentCommand<TValue> Do<TValue>(global::System.Func<TValue?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
         {
             if (propertyName == null)
                 throw new global::System.ArgumentNullException(nameof(propertyName), "Not able to determine property name to set.");
@@ -285,30 +285,30 @@ protected AsyncCommand<TValue> Do<TValue>(global::System.Func<TValue?, global::S
 
             if (!_commandStore.TryGetValue(propertyName, out var command))
             {
-                command = AsyncCommand<TValue>.Do(execute, this);
+                command = AsyncFluentCommand<TValue>.Do(execute, this);
                 _commandStore.Add(propertyName, command);
             }
             else
                 command.MarkAsBuilt();
 
-            return (AsyncCommand<TValue>)command;
+            return (AsyncFluentCommand<TValue>)command;
         }
 
         /// <summary>
         /// Creates an asynchronous command that supports cancellation and tracks execution state.
         /// <example>
         /// <code lang="csharp">
-        /// public AsyncCommand OkCommand => Do(async obj => await Task.Delay(1000)).If(obj => CanOk(obj));
+        /// public AsyncFluentCommand OkCommand => Do(async obj => await Task.Delay(1000)).If(obj => CanOk(obj));
         /// </code>
         /// </example>
         /// </summary>
         /// <remarks>Use generic version for type safety.</remarks>
         /// <param name="execute">The action to execute.</param>
         /// <param name="propertyName">The name of the property associated with the command.</param>
-        /// <returns>A new <see cref="AsyncCommand"/> instance.</returns>
+        /// <returns>A new <see cref="AsyncFluentCommand"/> instance.</returns>
         /// <exception cref="global::System.ArgumentNullException">Thrown when the property name is null or empty.</exception>
         /// <exception cref="global::System.ArgumentException">Thrown when the property name is .ctor.</exception>
-        protected AsyncCommand Do(global::System.Func<object?, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
+        protected AsyncFluentCommand Do(global::System.Func<object?, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
         {
             return Do((para, ct) => execute(para), propertyName);
         }
@@ -317,7 +317,7 @@ protected AsyncCommand Do(global::System.Func<object?, global::System.Threading.
         /// Creates an asynchronous command that passes a cancellation token to the method.
         /// <example>
         /// <code lang="csharp">
-        /// public AsyncCommand OkCommand => Do(Ok);
+        /// public AsyncFluentCommand OkCommand => Do(Ok);
         /// 
         /// private Task Ok(CancellationToken cancellationToken) { }
         /// </code>
@@ -326,10 +326,10 @@ protected AsyncCommand Do(global::System.Func<object?, global::System.Threading.
         /// <remarks>Use generic version for type safety.</remarks>
         /// <param name="execute">The action to execute.</param>
         /// <param name="propertyName">The name of the property associated with the command.</param>
-        /// <returns>A new <see cref="AsyncCommand"/> instance.</returns>
+        /// <returns>A new <see cref="AsyncFluentCommand"/> instance.</returns>
         /// <exception cref="global::System.ArgumentNullException">Thrown when the property name is null or empty.</exception>
         /// <exception cref="global::System.ArgumentException">Thrown when the property name is .ctor.</exception>
-        protected AsyncCommand Do(global::System.Func<object?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
+        protected AsyncFluentCommand Do(global::System.Func<object?, global::System.Threading.CancellationToken, global::System.Threading.Tasks.Task> execute, [global::System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null)
         {
             if (propertyName == null)
                 throw new global::System.ArgumentNullException(nameof(propertyName), "Not able to determine property name to set.");
@@ -340,13 +340,13 @@ protected AsyncCommand Do(global::System.Func<object?, global::System.Threading.
 
             if (!_commandStore.TryGetValue(propertyName, out var command))
             {
-                command = AsyncCommand.Do(execute, this);
+                command = AsyncFluentCommand.Do(execute, this);
                 _commandStore.Add(propertyName, command);
             }
             else
                 command.MarkAsBuilt();
 
-            return (AsyncCommand)command;
+            return (AsyncFluentCommand)command;
         }
 
         protected override void DisposeInternal()