Merge pull request #10829 from abpframework/liangshiwei/staticproxy

Use file scoped namespaces for static C# proxy classes

framework/src/Volo.Abp.AspNetCore.Mvc.Client.Common/ClientProxies/AbpApplicationConfigurationClientProxy.Generated.cs

@@ -9,15 +9,14 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations.ClientProxies
+namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IAbpApplicationConfigurationAppService), typeof(AbpApplicationConfigurationClientProxy))]
+public partial class AbpApplicationConfigurationClientProxy : ClientProxyBase<IAbpApplicationConfigurationAppService>, IAbpApplicationConfigurationAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IAbpApplicationConfigurationAppService), typeof(AbpApplicationConfigurationClientProxy))]
-    public partial class AbpApplicationConfigurationClientProxy : ClientProxyBase<IAbpApplicationConfigurationAppService>, IAbpApplicationConfigurationAppService
+    public virtual async Task<ApplicationConfigurationDto> GetAsync()
     {
-        public virtual async Task<ApplicationConfigurationDto> GetAsync()
-        {
-            return await RequestAsync<ApplicationConfigurationDto>(nameof(GetAsync));
-        }
+        return await RequestAsync<ApplicationConfigurationDto>(nameof(GetAsync));
     }
 }

framework/src/Volo.Abp.AspNetCore.Mvc.Client.Common/ClientProxies/AbpApplicationConfigurationClientProxy.cs

@@ -3,11 +3,10 @@
 
 using Volo.Abp.DependencyInjection;
 
-namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations.ClientProxies
+namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations.ClientProxies;
+
+[RemoteService(false)]
+[DisableConventionalRegistration]
+public partial class AbpApplicationConfigurationClientProxy
 {
-    [RemoteService(false)]
-    [DisableConventionalRegistration]
-    public partial class AbpApplicationConfigurationClientProxy
-    {
-    }
 }

framework/src/Volo.Abp.AspNetCore.Mvc.Client.Common/ClientProxies/AbpTenantClientProxy.Generated.cs

@@ -9,26 +9,25 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Abp.AspNetCore.Mvc.MultiTenancy;
 
 // ReSharper disable once CheckNamespace
-namespace Pages.Abp.MultiTenancy.ClientProxies
+namespace Pages.Abp.MultiTenancy.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IAbpTenantAppService), typeof(AbpTenantClientProxy))]
+public partial class AbpTenantClientProxy : ClientProxyBase<IAbpTenantAppService>, IAbpTenantAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IAbpTenantAppService), typeof(AbpTenantClientProxy))]
-    public partial class AbpTenantClientProxy : ClientProxyBase<IAbpTenantAppService>, IAbpTenantAppService
+    public virtual async Task<FindTenantResultDto> FindTenantByNameAsync(string name)
     {
-        public virtual async Task<FindTenantResultDto> FindTenantByNameAsync(string name)
+        return await RequestAsync<FindTenantResultDto>(nameof(FindTenantByNameAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<FindTenantResultDto>(nameof(FindTenantByNameAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), name }
-            });
-        }
+            { typeof(string), name }
+        });
+    }
 
-        public virtual async Task<FindTenantResultDto> FindTenantByIdAsync(Guid id)
+    public virtual async Task<FindTenantResultDto> FindTenantByIdAsync(Guid id)
+    {
+        return await RequestAsync<FindTenantResultDto>(nameof(FindTenantByIdAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<FindTenantResultDto>(nameof(FindTenantByIdAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

framework/src/Volo.Abp.AspNetCore.Mvc.Client.Common/ClientProxies/AbpTenantClientProxy.cs

@@ -4,11 +4,11 @@
 using Volo.Abp;
 using Volo.Abp.DependencyInjection;
 
-namespace Pages.Abp.MultiTenancy.ClientProxies
+namespace Pages.Abp.MultiTenancy.ClientProxies;
+
+[RemoteService(false)]
+[DisableConventionalRegistration]
+public partial class AbpTenantClientProxy
 {
-    [RemoteService(false)]
-    [DisableConventionalRegistration]
-    public partial class AbpTenantClientProxy
-    {
-    }
 }
+

framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/ServiceProxying/CSharp/CSharpServiceProxyGenerator.cs

@@ -29,23 +29,21 @@ public class CSharpServiceProxyGenerator : ServiceProxyGeneratorBase<CSharpServi
                                                    $"{Environment.NewLine}<using placeholder>" +
                                                    $"{Environment.NewLine}" +
                                                    $"{Environment.NewLine}// ReSharper disable once CheckNamespace" +
-                                                   $"{Environment.NewLine}namespace <namespace>" +
+                                                   $"{Environment.NewLine}namespace <namespace>;" +
+                                                   $"{Environment.NewLine}" +
+                                                   $"{Environment.NewLine}[Dependency(ReplaceServices = true)]" +
+                                                   $"{Environment.NewLine}[ExposeServices(typeof(<serviceInterface>), typeof(<className>))]" +
+                                                   $"{Environment.NewLine}public partial class <className> : ClientProxyBase<<serviceInterface>>, <serviceInterface>" +
                                                    $"{Environment.NewLine}{{" +
-                                                   $"{Environment.NewLine}    [Dependency(ReplaceServices = true)]" +
-                                                   $"{Environment.NewLine}    [ExposeServices(typeof(<serviceInterface>), typeof(<className>))]" +
-                                                   $"{Environment.NewLine}    public partial class <className> : ClientProxyBase<<serviceInterface>>, <serviceInterface>" +
-                                                   $"{Environment.NewLine}    {{" +
-                                                   $"{Environment.NewLine}        <method placeholder>" +
-                                                   $"{Environment.NewLine}    }}" +
+                                                   $"{Environment.NewLine}    <method placeholder>" +
                                                    $"{Environment.NewLine}}}" +
                                                    $"{Environment.NewLine}";
     private readonly string _clientProxyTemplate = "// This file is part of <className>, you can customize it here" +
                                                     $"{Environment.NewLine}// ReSharper disable once CheckNamespace" +
-                                                    $"{Environment.NewLine}namespace <namespace>" +
+                                                    $"{Environment.NewLine}namespace <namespace>;" +
+                                                    $"{Environment.NewLine}" +
+                                                    $"{Environment.NewLine}public partial class <className>" +
                                                     $"{Environment.NewLine}{{" +
-                                                    $"{Environment.NewLine}    public partial class <className>" +
-                                                    $"{Environment.NewLine}    {{" +
-                                                    $"{Environment.NewLine}    }}" +
                                                     $"{Environment.NewLine}}}" +
                                                     $"{Environment.NewLine}";
     private readonly List<string> _usingNamespaceList = new()

modules/account/src/Volo.Abp.Account.HttpApi.Client/ClientProxies/AccountClientProxy.Generated.cs

@@ -10,34 +10,33 @@ using Volo.Abp.Account;
 using Volo.Abp.Identity;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.Account.ClientProxies
+namespace Volo.Abp.Account.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IAccountAppService), typeof(AccountClientProxy))]
+public partial class AccountClientProxy : ClientProxyBase<IAccountAppService>, IAccountAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IAccountAppService), typeof(AccountClientProxy))]
-    public partial class AccountClientProxy : ClientProxyBase<IAccountAppService>, IAccountAppService
+    public virtual async Task<IdentityUserDto> RegisterAsync(RegisterDto input)
     {
-        public virtual async Task<IdentityUserDto> RegisterAsync(RegisterDto input)
+        return await RequestAsync<IdentityUserDto>(nameof(RegisterAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IdentityUserDto>(nameof(RegisterAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(RegisterDto), input }
-            });
-        }
+            { typeof(RegisterDto), input }
+        });
+    }
 
-        public virtual async Task SendPasswordResetCodeAsync(SendPasswordResetCodeDto input)
+    public virtual async Task SendPasswordResetCodeAsync(SendPasswordResetCodeDto input)
+    {
+        await RequestAsync(nameof(SendPasswordResetCodeAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(SendPasswordResetCodeAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(SendPasswordResetCodeDto), input }
-            });
-        }
+            { typeof(SendPasswordResetCodeDto), input }
+        });
+    }
 
-        public virtual async Task ResetPasswordAsync(ResetPasswordDto input)
+    public virtual async Task ResetPasswordAsync(ResetPasswordDto input)
+    {
+        await RequestAsync(nameof(ResetPasswordAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(ResetPasswordAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(ResetPasswordDto), input }
-            });
-        }
+            { typeof(ResetPasswordDto), input }
+        });
     }
 }

modules/account/src/Volo.Abp.Account.HttpApi.Client/ClientProxies/ProfileClientProxy.Generated.cs

@@ -9,31 +9,30 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Abp.Identity;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.Account.ClientProxies
+namespace Volo.Abp.Account.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IProfileAppService), typeof(ProfileClientProxy))]
+public partial class ProfileClientProxy : ClientProxyBase<IProfileAppService>, IProfileAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IProfileAppService), typeof(ProfileClientProxy))]
-    public partial class ProfileClientProxy : ClientProxyBase<IProfileAppService>, IProfileAppService
+    public virtual async Task<ProfileDto> GetAsync()
     {
-        public virtual async Task<ProfileDto> GetAsync()
-        {
-            return await RequestAsync<ProfileDto>(nameof(GetAsync));
-        }
+        return await RequestAsync<ProfileDto>(nameof(GetAsync));
+    }
 
-        public virtual async Task<ProfileDto> UpdateAsync(UpdateProfileDto input)
+    public virtual async Task<ProfileDto> UpdateAsync(UpdateProfileDto input)
+    {
+        return await RequestAsync<ProfileDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ProfileDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(UpdateProfileDto), input }
-            });
-        }
+            { typeof(UpdateProfileDto), input }
+        });
+    }
 
-        public virtual async Task ChangePasswordAsync(ChangePasswordInput input)
+    public virtual async Task ChangePasswordAsync(ChangePasswordInput input)
+    {
+        await RequestAsync(nameof(ChangePasswordAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(ChangePasswordAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(ChangePasswordInput), input }
-            });
-        }
+            { typeof(ChangePasswordInput), input }
+        });
     }
 }

modules/blogging/src/Volo.Blogging.Admin.HttpApi.Client/ClientProxies/BlogManagementClientProxy.Generated.cs

@@ -10,56 +10,55 @@ using Volo.Blogging.Admin.Blogs;
 using Volo.Blogging.Blogs.Dtos;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.Admin.ClientProxies
+namespace Volo.Blogging.Admin.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IBlogManagementAppService), typeof(BlogManagementClientProxy))]
+public partial class BlogManagementClientProxy : ClientProxyBase<IBlogManagementAppService>, IBlogManagementAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IBlogManagementAppService), typeof(BlogManagementClientProxy))]
-    public partial class BlogManagementClientProxy : ClientProxyBase<IBlogManagementAppService>, IBlogManagementAppService
+    public virtual async Task<ListResultDto<BlogDto>> GetListAsync()
     {
-        public virtual async Task<ListResultDto<BlogDto>> GetListAsync()
-        {
-            return await RequestAsync<ListResultDto<BlogDto>>(nameof(GetListAsync));
-        }
+        return await RequestAsync<ListResultDto<BlogDto>>(nameof(GetListAsync));
+    }
 
-        public virtual async Task<BlogDto> GetAsync(Guid id)
+    public virtual async Task<BlogDto> GetAsync(Guid id)
+    {
+        return await RequestAsync<BlogDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<BlogDto> CreateAsync(CreateBlogDto input)
+    public virtual async Task<BlogDto> CreateAsync(CreateBlogDto input)
+    {
+        return await RequestAsync<BlogDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(CreateBlogDto), input }
-            });
-        }
+            { typeof(CreateBlogDto), input }
+        });
+    }
 
-        public virtual async Task<BlogDto> UpdateAsync(Guid id, UpdateBlogDto input)
+    public virtual async Task<BlogDto> UpdateAsync(Guid id, UpdateBlogDto input)
+    {
+        return await RequestAsync<BlogDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(UpdateBlogDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(UpdateBlogDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task ClearCacheAsync(Guid id)
+    public virtual async Task ClearCacheAsync(Guid id)
+    {
+        await RequestAsync(nameof(ClearCacheAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(ClearCacheAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/blogging/src/Volo.Blogging.Admin.HttpApi.Client/ClientProxies/BlogManagementClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of BlogManagementClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.Admin.ClientProxies
+namespace Volo.Blogging.Admin.ClientProxies;
+
+public partial class BlogManagementClientProxy
 {
-    public partial class BlogManagementClientProxy
-    {
-    }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/BlogFilesClientProxy.Generated.cs

@@ -10,34 +10,33 @@ using Volo.Blogging.Files;
 using Volo.Abp.Content;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IFileAppService), typeof(BlogFilesClientProxy))]
+public partial class BlogFilesClientProxy : ClientProxyBase<IFileAppService>, IFileAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IFileAppService), typeof(BlogFilesClientProxy))]
-    public partial class BlogFilesClientProxy : ClientProxyBase<IFileAppService>, IFileAppService
+    public virtual async Task<RawFileDto> GetAsync(string name)
     {
-        public virtual async Task<RawFileDto> GetAsync(string name)
+        return await RequestAsync<RawFileDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<RawFileDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), name }
-            });
-        }
+            { typeof(string), name }
+        });
+    }
 
-        public virtual async Task<IRemoteStreamContent> GetFileAsync(string name)
+    public virtual async Task<IRemoteStreamContent> GetFileAsync(string name)
+    {
+        return await RequestAsync<IRemoteStreamContent>(nameof(GetFileAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IRemoteStreamContent>(nameof(GetFileAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), name }
-            });
-        }
+            { typeof(string), name }
+        });
+    }
 
-        public virtual async Task<FileUploadOutputDto> CreateAsync(FileUploadInputDto input)
+    public virtual async Task<FileUploadOutputDto> CreateAsync(FileUploadInputDto input)
+    {
+        return await RequestAsync<FileUploadOutputDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<FileUploadOutputDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(FileUploadInputDto), input }
-            });
-        }
+            { typeof(FileUploadInputDto), input }
+        });
     }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/BlogFilesClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of BlogFilesClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+public partial class BlogFilesClientProxy
 {
-    public partial class BlogFilesClientProxy
-    {
-    }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/BlogsClientProxy.Generated.cs

@@ -10,31 +10,30 @@ using Volo.Blogging.Blogs;
 using Volo.Blogging.Blogs.Dtos;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IBlogAppService), typeof(BlogsClientProxy))]
+public partial class BlogsClientProxy : ClientProxyBase<IBlogAppService>, IBlogAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IBlogAppService), typeof(BlogsClientProxy))]
-    public partial class BlogsClientProxy : ClientProxyBase<IBlogAppService>, IBlogAppService
+    public virtual async Task<ListResultDto<BlogDto>> GetListAsync()
     {
-        public virtual async Task<ListResultDto<BlogDto>> GetListAsync()
-        {
-            return await RequestAsync<ListResultDto<BlogDto>>(nameof(GetListAsync));
-        }
+        return await RequestAsync<ListResultDto<BlogDto>>(nameof(GetListAsync));
+    }
 
-        public virtual async Task<BlogDto> GetByShortNameAsync(string shortName)
+    public virtual async Task<BlogDto> GetByShortNameAsync(string shortName)
+    {
+        return await RequestAsync<BlogDto>(nameof(GetByShortNameAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogDto>(nameof(GetByShortNameAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), shortName }
-            });
-        }
+            { typeof(string), shortName }
+        });
+    }
 
-        public virtual async Task<BlogDto> GetAsync(Guid id)
+    public virtual async Task<BlogDto> GetAsync(Guid id)
+    {
+        return await RequestAsync<BlogDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/BlogsClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of BlogsClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+public partial class BlogsClientProxy
 {
-    public partial class BlogsClientProxy
-    {
-    }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/CommentsClientProxy.Generated.cs

@@ -11,43 +11,42 @@ using System.Collections.Generic;
 using Volo.Blogging.Comments.Dtos;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(ICommentAppService), typeof(CommentsClientProxy))]
+public partial class CommentsClientProxy : ClientProxyBase<ICommentAppService>, ICommentAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(ICommentAppService), typeof(CommentsClientProxy))]
-    public partial class CommentsClientProxy : ClientProxyBase<ICommentAppService>, ICommentAppService
+    public virtual async Task<List<CommentWithRepliesDto>> GetHierarchicalListOfPostAsync(Guid postId)
     {
-        public virtual async Task<List<CommentWithRepliesDto>> GetHierarchicalListOfPostAsync(Guid postId)
+        return await RequestAsync<List<CommentWithRepliesDto>>(nameof(GetHierarchicalListOfPostAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<List<CommentWithRepliesDto>>(nameof(GetHierarchicalListOfPostAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), postId }
-            });
-        }
+            { typeof(Guid), postId }
+        });
+    }
 
-        public virtual async Task<CommentWithDetailsDto> CreateAsync(CreateCommentDto input)
+    public virtual async Task<CommentWithDetailsDto> CreateAsync(CreateCommentDto input)
+    {
+        return await RequestAsync<CommentWithDetailsDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<CommentWithDetailsDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(CreateCommentDto), input }
-            });
-        }
+            { typeof(CreateCommentDto), input }
+        });
+    }
 
-        public virtual async Task<CommentWithDetailsDto> UpdateAsync(Guid id, UpdateCommentDto input)
+    public virtual async Task<CommentWithDetailsDto> UpdateAsync(Guid id, UpdateCommentDto input)
+    {
+        return await RequestAsync<CommentWithDetailsDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<CommentWithDetailsDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(UpdateCommentDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(UpdateCommentDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/CommentsClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of CommentsClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+public partial class CommentsClientProxy
 {
-    public partial class CommentsClientProxy
-    {
-    }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/PostsClientProxy.Generated.cs

@@ -9,68 +9,67 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Blogging.Posts;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IPostAppService), typeof(PostsClientProxy))]
+public partial class PostsClientProxy : ClientProxyBase<IPostAppService>, IPostAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IPostAppService), typeof(PostsClientProxy))]
-    public partial class PostsClientProxy : ClientProxyBase<IPostAppService>, IPostAppService
+    public virtual async Task<ListResultDto<PostWithDetailsDto>> GetListByBlogIdAndTagNameAsync(Guid blogId, string tagName)
     {
-        public virtual async Task<ListResultDto<PostWithDetailsDto>> GetListByBlogIdAndTagNameAsync(Guid blogId, string tagName)
+        return await RequestAsync<ListResultDto<PostWithDetailsDto>>(nameof(GetListByBlogIdAndTagNameAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ListResultDto<PostWithDetailsDto>>(nameof(GetListByBlogIdAndTagNameAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), blogId },
-                { typeof(string), tagName }
-            });
-        }
+            { typeof(Guid), blogId },
+            { typeof(string), tagName }
+        });
+    }
 
-        public virtual async Task<ListResultDto<PostWithDetailsDto>> GetTimeOrderedListAsync(Guid blogId)
+    public virtual async Task<ListResultDto<PostWithDetailsDto>> GetTimeOrderedListAsync(Guid blogId)
+    {
+        return await RequestAsync<ListResultDto<PostWithDetailsDto>>(nameof(GetTimeOrderedListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ListResultDto<PostWithDetailsDto>>(nameof(GetTimeOrderedListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), blogId }
-            });
-        }
+            { typeof(Guid), blogId }
+        });
+    }
 
-        public virtual async Task<PostWithDetailsDto> GetForReadingAsync(GetPostInput input)
+    public virtual async Task<PostWithDetailsDto> GetForReadingAsync(GetPostInput input)
+    {
+        return await RequestAsync<PostWithDetailsDto>(nameof(GetForReadingAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PostWithDetailsDto>(nameof(GetForReadingAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetPostInput), input }
-            });
-        }
+            { typeof(GetPostInput), input }
+        });
+    }
 
-        public virtual async Task<PostWithDetailsDto> GetAsync(Guid id)
+    public virtual async Task<PostWithDetailsDto> GetAsync(Guid id)
+    {
+        return await RequestAsync<PostWithDetailsDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PostWithDetailsDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<PostWithDetailsDto> CreateAsync(CreatePostDto input)
+    public virtual async Task<PostWithDetailsDto> CreateAsync(CreatePostDto input)
+    {
+        return await RequestAsync<PostWithDetailsDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PostWithDetailsDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(CreatePostDto), input }
-            });
-        }
+            { typeof(CreatePostDto), input }
+        });
+    }
 
-        public virtual async Task<PostWithDetailsDto> UpdateAsync(Guid id, UpdatePostDto input)
+    public virtual async Task<PostWithDetailsDto> UpdateAsync(Guid id, UpdatePostDto input)
+    {
+        return await RequestAsync<PostWithDetailsDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PostWithDetailsDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(UpdatePostDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(UpdatePostDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/PostsClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of PostsClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+public partial class PostsClientProxy
 {
-    public partial class PostsClientProxy
-    {
-    }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/TagsClientProxy.Generated.cs

@@ -11,19 +11,18 @@ using System.Collections.Generic;
 using Volo.Blogging.Tagging.Dtos;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(ITagAppService), typeof(TagsClientProxy))]
+public partial class TagsClientProxy : ClientProxyBase<ITagAppService>, ITagAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(ITagAppService), typeof(TagsClientProxy))]
-    public partial class TagsClientProxy : ClientProxyBase<ITagAppService>, ITagAppService
+    public virtual async Task<List<TagDto>> GetPopularTagsAsync(Guid blogId, GetPopularTagsInput input)
     {
-        public virtual async Task<List<TagDto>> GetPopularTagsAsync(Guid blogId, GetPopularTagsInput input)
+        return await RequestAsync<List<TagDto>>(nameof(GetPopularTagsAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<List<TagDto>>(nameof(GetPopularTagsAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), blogId },
-                { typeof(GetPopularTagsInput), input }
-            });
-        }
+            { typeof(Guid), blogId },
+            { typeof(GetPopularTagsInput), input }
+        });
     }
 }

modules/blogging/src/Volo.Blogging.HttpApi.Client/ClientProxies/TagsClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of TagsClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Blogging.ClientProxies
+namespace Volo.Blogging.ClientProxies;
+
+public partial class TagsClientProxy
 {
-    public partial class TagsClientProxy
-    {
-    }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi.Client/ClientProxies/BlogAdminClientProxy.Generated.cs

@@ -9,51 +9,50 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Admin.Blogs;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Admin.Blogs.ClientProxies
+namespace Volo.CmsKit.Admin.Blogs.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IBlogAdminAppService), typeof(BlogAdminClientProxy))]
+public partial class BlogAdminClientProxy : ClientProxyBase<IBlogAdminAppService>, IBlogAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IBlogAdminAppService), typeof(BlogAdminClientProxy))]
-    public partial class BlogAdminClientProxy : ClientProxyBase<IBlogAdminAppService>, IBlogAdminAppService
+    public virtual async Task<BlogDto> GetAsync(Guid id)
     {
-        public virtual async Task<BlogDto> GetAsync(Guid id)
+        return await RequestAsync<BlogDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<PagedResultDto<BlogDto>> GetListAsync(BlogGetListInput input)
+    public virtual async Task<PagedResultDto<BlogDto>> GetListAsync(BlogGetListInput input)
+    {
+        return await RequestAsync<PagedResultDto<BlogDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<BlogDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(BlogGetListInput), input }
-            });
-        }
+            { typeof(BlogGetListInput), input }
+        });
+    }
 
-        public virtual async Task<BlogDto> CreateAsync(CreateBlogDto input)
+    public virtual async Task<BlogDto> CreateAsync(CreateBlogDto input)
+    {
+        return await RequestAsync<BlogDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(CreateBlogDto), input }
-            });
-        }
+            { typeof(CreateBlogDto), input }
+        });
+    }
 
-        public virtual async Task<BlogDto> UpdateAsync(Guid id, UpdateBlogDto input)
+    public virtual async Task<BlogDto> UpdateAsync(Guid id, UpdateBlogDto input)
+    {
+        return await RequestAsync<BlogDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(UpdateBlogDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(UpdateBlogDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi.Client/ClientProxies/BlogFeatureAdminClientProxy.Generated.cs

@@ -11,27 +11,26 @@ using System.Collections.Generic;
 using Volo.CmsKit.Blogs;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Admin.Blogs.ClientProxies
+namespace Volo.CmsKit.Admin.Blogs.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IBlogFeatureAdminAppService), typeof(BlogFeatureAdminClientProxy))]
+public partial class BlogFeatureAdminClientProxy : ClientProxyBase<IBlogFeatureAdminAppService>, IBlogFeatureAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IBlogFeatureAdminAppService), typeof(BlogFeatureAdminClientProxy))]
-    public partial class BlogFeatureAdminClientProxy : ClientProxyBase<IBlogFeatureAdminAppService>, IBlogFeatureAdminAppService
+    public virtual async Task<List<BlogFeatureDto>> GetListAsync(Guid blogId)
     {
-        public virtual async Task<List<BlogFeatureDto>> GetListAsync(Guid blogId)
+        return await RequestAsync<List<BlogFeatureDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<List<BlogFeatureDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), blogId }
-            });
-        }
+            { typeof(Guid), blogId }
+        });
+    }
 
-        public virtual async Task SetAsync(Guid blogId, BlogFeatureInputDto dto)
+    public virtual async Task SetAsync(Guid blogId, BlogFeatureInputDto dto)
+    {
+        await RequestAsync(nameof(SetAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(SetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), blogId },
-                { typeof(BlogFeatureInputDto), dto }
-            });
-        }
+            { typeof(Guid), blogId },
+            { typeof(BlogFeatureInputDto), dto }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi.Client/ClientProxies/BlogPostAdminClientProxy.Generated.cs

@@ -9,51 +9,50 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Admin.Blogs;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Admin.Blogs.ClientProxies
+namespace Volo.CmsKit.Admin.Blogs.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IBlogPostAdminAppService), typeof(BlogPostAdminClientProxy))]
+public partial class BlogPostAdminClientProxy : ClientProxyBase<IBlogPostAdminAppService>, IBlogPostAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IBlogPostAdminAppService), typeof(BlogPostAdminClientProxy))]
-    public partial class BlogPostAdminClientProxy : ClientProxyBase<IBlogPostAdminAppService>, IBlogPostAdminAppService
+    public virtual async Task<BlogPostDto> CreateAsync(CreateBlogPostDto input)
     {
-        public virtual async Task<BlogPostDto> CreateAsync(CreateBlogPostDto input)
+        return await RequestAsync<BlogPostDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogPostDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(CreateBlogPostDto), input }
-            });
-        }
+            { typeof(CreateBlogPostDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<BlogPostDto> GetAsync(Guid id)
+    public virtual async Task<BlogPostDto> GetAsync(Guid id)
+    {
+        return await RequestAsync<BlogPostDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogPostDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<PagedResultDto<BlogPostListDto>> GetListAsync(BlogPostGetListInput input)
+    public virtual async Task<PagedResultDto<BlogPostListDto>> GetListAsync(BlogPostGetListInput input)
+    {
+        return await RequestAsync<PagedResultDto<BlogPostListDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<BlogPostListDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(BlogPostGetListInput), input }
-            });
-        }
+            { typeof(BlogPostGetListInput), input }
+        });
+    }
 
-        public virtual async Task<BlogPostDto> UpdateAsync(Guid id, UpdateBlogPostDto input)
+    public virtual async Task<BlogPostDto> UpdateAsync(Guid id, UpdateBlogPostDto input)
+    {
+        return await RequestAsync<BlogPostDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogPostDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(UpdateBlogPostDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(UpdateBlogPostDto), input }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi.Client/ClientProxies/CommentAdminClientProxy.Generated.cs

@@ -9,34 +9,33 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Admin.Comments;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Admin.Comments.ClientProxies
+namespace Volo.CmsKit.Admin.Comments.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(ICommentAdminAppService), typeof(CommentAdminClientProxy))]
+public partial class CommentAdminClientProxy : ClientProxyBase<ICommentAdminAppService>, ICommentAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(ICommentAdminAppService), typeof(CommentAdminClientProxy))]
-    public partial class CommentAdminClientProxy : ClientProxyBase<ICommentAdminAppService>, ICommentAdminAppService
+    public virtual async Task<PagedResultDto<CommentWithAuthorDto>> GetListAsync(CommentGetListInput input)
     {
-        public virtual async Task<PagedResultDto<CommentWithAuthorDto>> GetListAsync(CommentGetListInput input)
+        return await RequestAsync<PagedResultDto<CommentWithAuthorDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<CommentWithAuthorDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(CommentGetListInput), input }
-            });
-        }
+            { typeof(CommentGetListInput), input }
+        });
+    }
 
-        public virtual async Task<CommentWithAuthorDto> GetAsync(Guid id)
+    public virtual async Task<CommentWithAuthorDto> GetAsync(Guid id)
+    {
+        return await RequestAsync<CommentWithAuthorDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<CommentWithAuthorDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi.Client/ClientProxies/EntityTagAdminClientProxy.Generated.cs

@@ -9,34 +9,33 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Admin.Tags;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Admin.Tags.ClientProxies
+namespace Volo.CmsKit.Admin.Tags.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IEntityTagAdminAppService), typeof(EntityTagAdminClientProxy))]
+public partial class EntityTagAdminClientProxy : ClientProxyBase<IEntityTagAdminAppService>, IEntityTagAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IEntityTagAdminAppService), typeof(EntityTagAdminClientProxy))]
-    public partial class EntityTagAdminClientProxy : ClientProxyBase<IEntityTagAdminAppService>, IEntityTagAdminAppService
+    public virtual async Task AddTagToEntityAsync(EntityTagCreateDto input)
     {
-        public virtual async Task AddTagToEntityAsync(EntityTagCreateDto input)
+        await RequestAsync(nameof(AddTagToEntityAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(AddTagToEntityAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(EntityTagCreateDto), input }
-            });
-        }
+            { typeof(EntityTagCreateDto), input }
+        });
+    }
 
-        public virtual async Task RemoveTagFromEntityAsync(EntityTagRemoveDto input)
+    public virtual async Task RemoveTagFromEntityAsync(EntityTagRemoveDto input)
+    {
+        await RequestAsync(nameof(RemoveTagFromEntityAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(RemoveTagFromEntityAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(EntityTagRemoveDto), input }
-            });
-        }
+            { typeof(EntityTagRemoveDto), input }
+        });
+    }
 
-        public virtual async Task SetEntityTagsAsync(EntityTagSetDto input)
+    public virtual async Task SetEntityTagsAsync(EntityTagSetDto input)
+    {
+        await RequestAsync(nameof(SetEntityTagsAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(SetEntityTagsAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(EntityTagSetDto), input }
-            });
-        }
+            { typeof(EntityTagSetDto), input }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi.Client/ClientProxies/MediaDescriptorAdminClientProxy.Generated.cs

@@ -9,27 +9,26 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Admin.MediaDescriptors;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Admin.MediaDescriptors.ClientProxies
+namespace Volo.CmsKit.Admin.MediaDescriptors.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IMediaDescriptorAdminAppService), typeof(MediaDescriptorAdminClientProxy))]
+public partial class MediaDescriptorAdminClientProxy : ClientProxyBase<IMediaDescriptorAdminAppService>, IMediaDescriptorAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IMediaDescriptorAdminAppService), typeof(MediaDescriptorAdminClientProxy))]
-    public partial class MediaDescriptorAdminClientProxy : ClientProxyBase<IMediaDescriptorAdminAppService>, IMediaDescriptorAdminAppService
+    public virtual async Task<MediaDescriptorDto> CreateAsync(string entityType, CreateMediaInputWithStream inputStream)
     {
-        public virtual async Task<MediaDescriptorDto> CreateAsync(string entityType, CreateMediaInputWithStream inputStream)
+        return await RequestAsync<MediaDescriptorDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<MediaDescriptorDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(CreateMediaInputWithStream), inputStream }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(CreateMediaInputWithStream), inputStream }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi.Client/ClientProxies/MenuItemAdminClientProxy.Generated.cs

@@ -10,65 +10,64 @@ using Volo.CmsKit.Admin.Menus;
 using Volo.CmsKit.Menus;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Admin.Menus.ClientProxies
+namespace Volo.CmsKit.Admin.Menus.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IMenuItemAdminAppService), typeof(MenuItemAdminClientProxy))]
+public partial class MenuItemAdminClientProxy : ClientProxyBase<IMenuItemAdminAppService>, IMenuItemAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IMenuItemAdminAppService), typeof(MenuItemAdminClientProxy))]
-    public partial class MenuItemAdminClientProxy : ClientProxyBase<IMenuItemAdminAppService>, IMenuItemAdminAppService
+    public virtual async Task<ListResultDto<MenuItemDto>> GetListAsync()
     {
-        public virtual async Task<ListResultDto<MenuItemDto>> GetListAsync()
-        {
-            return await RequestAsync<ListResultDto<MenuItemDto>>(nameof(GetListAsync));
-        }
+        return await RequestAsync<ListResultDto<MenuItemDto>>(nameof(GetListAsync));
+    }
 
-        public virtual async Task<MenuItemDto> GetAsync(Guid id)
+    public virtual async Task<MenuItemDto> GetAsync(Guid id)
+    {
+        return await RequestAsync<MenuItemDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<MenuItemDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<MenuItemDto> CreateAsync(MenuItemCreateInput input)
+    public virtual async Task<MenuItemDto> CreateAsync(MenuItemCreateInput input)
+    {
+        return await RequestAsync<MenuItemDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<MenuItemDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(MenuItemCreateInput), input }
-            });
-        }
+            { typeof(MenuItemCreateInput), input }
+        });
+    }
 
-        public virtual async Task<MenuItemDto> UpdateAsync(Guid id, MenuItemUpdateInput input)
+    public virtual async Task<MenuItemDto> UpdateAsync(Guid id, MenuItemUpdateInput input)
+    {
+        return await RequestAsync<MenuItemDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<MenuItemDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(MenuItemUpdateInput), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(MenuItemUpdateInput), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task MoveMenuItemAsync(Guid id, MenuItemMoveInput input)
+    public virtual async Task MoveMenuItemAsync(Guid id, MenuItemMoveInput input)
+    {
+        await RequestAsync(nameof(MoveMenuItemAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(MoveMenuItemAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(MenuItemMoveInput), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(MenuItemMoveInput), input }
+        });
+    }
 
-        public virtual async Task<PagedResultDto<PageLookupDto>> GetPageLookupAsync(PageLookupInputDto input)
+    public virtual async Task<PagedResultDto<PageLookupDto>> GetPageLookupAsync(PageLookupInputDto input)
+    {
+        return await RequestAsync<PagedResultDto<PageLookupDto>>(nameof(GetPageLookupAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<PageLookupDto>>(nameof(GetPageLookupAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(PageLookupInputDto), input }
-            });
-        }
+            { typeof(PageLookupInputDto), input }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi.Client/ClientProxies/PageAdminClientProxy.Generated.cs

@@ -9,51 +9,50 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Admin.Pages;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Admin.Pages.ClientProxies
+namespace Volo.CmsKit.Admin.Pages.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IPageAdminAppService), typeof(PageAdminClientProxy))]
+public partial class PageAdminClientProxy : ClientProxyBase<IPageAdminAppService>, IPageAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IPageAdminAppService), typeof(PageAdminClientProxy))]
-    public partial class PageAdminClientProxy : ClientProxyBase<IPageAdminAppService>, IPageAdminAppService
+    public virtual async Task<PageDto> GetAsync(Guid id)
     {
-        public virtual async Task<PageDto> GetAsync(Guid id)
+        return await RequestAsync<PageDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PageDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<PagedResultDto<PageDto>> GetListAsync(GetPagesInputDto input)
+    public virtual async Task<PagedResultDto<PageDto>> GetListAsync(GetPagesInputDto input)
+    {
+        return await RequestAsync<PagedResultDto<PageDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<PageDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetPagesInputDto), input }
-            });
-        }
+            { typeof(GetPagesInputDto), input }
+        });
+    }
 
-        public virtual async Task<PageDto> CreateAsync(CreatePageInputDto input)
+    public virtual async Task<PageDto> CreateAsync(CreatePageInputDto input)
+    {
+        return await RequestAsync<PageDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PageDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(CreatePageInputDto), input }
-            });
-        }
+            { typeof(CreatePageInputDto), input }
+        });
+    }
 
-        public virtual async Task<PageDto> UpdateAsync(Guid id, UpdatePageInputDto input)
+    public virtual async Task<PageDto> UpdateAsync(Guid id, UpdatePageInputDto input)
+    {
+        return await RequestAsync<PageDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PageDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(UpdatePageInputDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(UpdatePageInputDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Admin.HttpApi.Client/ClientProxies/TagAdminClientProxy.Generated.cs

@@ -11,56 +11,55 @@ using Volo.CmsKit.Tags;
 using System.Collections.Generic;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Admin.Tags.ClientProxies
+namespace Volo.CmsKit.Admin.Tags.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(ITagAdminAppService), typeof(TagAdminClientProxy))]
+public partial class TagAdminClientProxy : ClientProxyBase<ITagAdminAppService>, ITagAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(ITagAdminAppService), typeof(TagAdminClientProxy))]
-    public partial class TagAdminClientProxy : ClientProxyBase<ITagAdminAppService>, ITagAdminAppService
+    public virtual async Task<TagDto> CreateAsync(TagCreateDto input)
     {
-        public virtual async Task<TagDto> CreateAsync(TagCreateDto input)
+        return await RequestAsync<TagDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<TagDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(TagCreateDto), input }
-            });
-        }
+            { typeof(TagCreateDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<TagDto> GetAsync(Guid id)
+    public virtual async Task<TagDto> GetAsync(Guid id)
+    {
+        return await RequestAsync<TagDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<TagDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<PagedResultDto<TagDto>> GetListAsync(TagGetListInput input)
+    public virtual async Task<PagedResultDto<TagDto>> GetListAsync(TagGetListInput input)
+    {
+        return await RequestAsync<PagedResultDto<TagDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<TagDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(TagGetListInput), input }
-            });
-        }
+            { typeof(TagGetListInput), input }
+        });
+    }
 
-        public virtual async Task<TagDto> UpdateAsync(Guid id, TagUpdateDto input)
+    public virtual async Task<TagDto> UpdateAsync(Guid id, TagUpdateDto input)
+    {
+        return await RequestAsync<TagDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<TagDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(TagUpdateDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(TagUpdateDto), input }
+        });
+    }
 
-        public virtual async Task<List<TagDefinitionDto>> GetTagDefinitionsAsync()
-        {
-            return await RequestAsync<List<TagDefinitionDto>>(nameof(GetTagDefinitionsAsync));
-        }
+    public virtual async Task<List<TagDefinitionDto>> GetTagDefinitionsAsync()
+    {
+        return await RequestAsync<List<TagDefinitionDto>>(nameof(GetTagDefinitionsAsync));
     }
 }

modules/cms-kit/src/Volo.CmsKit.Common.HttpApi.Client/ClientProxies/BlogFeatureClientProxy.Generated.cs

@@ -9,19 +9,18 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Blogs;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Blogs.ClientProxies
+namespace Volo.CmsKit.Blogs.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IBlogFeatureAppService), typeof(BlogFeatureClientProxy))]
+public partial class BlogFeatureClientProxy : ClientProxyBase<IBlogFeatureAppService>, IBlogFeatureAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IBlogFeatureAppService), typeof(BlogFeatureClientProxy))]
-    public partial class BlogFeatureClientProxy : ClientProxyBase<IBlogFeatureAppService>, IBlogFeatureAppService
+    public virtual async Task<BlogFeatureDto> GetOrDefaultAsync(Guid blogId, string featureName)
     {
-        public virtual async Task<BlogFeatureDto> GetOrDefaultAsync(Guid blogId, string featureName)
+        return await RequestAsync<BlogFeatureDto>(nameof(GetOrDefaultAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogFeatureDto>(nameof(GetOrDefaultAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), blogId },
-                { typeof(string), featureName }
-            });
-        }
+            { typeof(Guid), blogId },
+            { typeof(string), featureName }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Common.HttpApi.Client/ClientProxies/MediaDescriptorClientProxy.Generated.cs

@@ -10,18 +10,17 @@ using Volo.CmsKit.MediaDescriptors;
 using Volo.Abp.Content;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.MediaDescriptors.ClientProxies
+namespace Volo.CmsKit.MediaDescriptors.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IMediaDescriptorAppService), typeof(MediaDescriptorClientProxy))]
+public partial class MediaDescriptorClientProxy : ClientProxyBase<IMediaDescriptorAppService>, IMediaDescriptorAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IMediaDescriptorAppService), typeof(MediaDescriptorClientProxy))]
-    public partial class MediaDescriptorClientProxy : ClientProxyBase<IMediaDescriptorAppService>, IMediaDescriptorAppService
+    public virtual async Task<RemoteStreamContent> DownloadAsync(Guid id)
     {
-        public virtual async Task<RemoteStreamContent> DownloadAsync(Guid id)
+        return await RequestAsync<RemoteStreamContent>(nameof(DownloadAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<RemoteStreamContent>(nameof(DownloadAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Public.HttpApi.Client/ClientProxies/BlogPostPublicClientProxy.Generated.cs

@@ -9,28 +9,27 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Public.Blogs;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Public.Blogs.ClientProxies
+namespace Volo.CmsKit.Public.Blogs.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IBlogPostPublicAppService), typeof(BlogPostPublicClientProxy))]
+public partial class BlogPostPublicClientProxy : ClientProxyBase<IBlogPostPublicAppService>, IBlogPostPublicAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IBlogPostPublicAppService), typeof(BlogPostPublicClientProxy))]
-    public partial class BlogPostPublicClientProxy : ClientProxyBase<IBlogPostPublicAppService>, IBlogPostPublicAppService
+    public virtual async Task<BlogPostPublicDto> GetAsync(string blogSlug, string blogPostSlug)
     {
-        public virtual async Task<BlogPostPublicDto> GetAsync(string blogSlug, string blogPostSlug)
+        return await RequestAsync<BlogPostPublicDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<BlogPostPublicDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), blogSlug },
-                { typeof(string), blogPostSlug }
-            });
-        }
+            { typeof(string), blogSlug },
+            { typeof(string), blogPostSlug }
+        });
+    }
 
-        public virtual async Task<PagedResultDto<BlogPostPublicDto>> GetListAsync(string blogSlug, PagedAndSortedResultRequestDto input)
+    public virtual async Task<PagedResultDto<BlogPostPublicDto>> GetListAsync(string blogSlug, PagedAndSortedResultRequestDto input)
+    {
+        return await RequestAsync<PagedResultDto<BlogPostPublicDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<BlogPostPublicDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), blogSlug },
-                { typeof(PagedAndSortedResultRequestDto), input }
-            });
-        }
+            { typeof(string), blogSlug },
+            { typeof(PagedAndSortedResultRequestDto), input }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Public.HttpApi.Client/ClientProxies/CommentPublicClientProxy.Generated.cs

@@ -9,46 +9,45 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Public.Comments;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Public.Comments.ClientProxies
+namespace Volo.CmsKit.Public.Comments.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(ICommentPublicAppService), typeof(CommentPublicClientProxy))]
+public partial class CommentPublicClientProxy : ClientProxyBase<ICommentPublicAppService>, ICommentPublicAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(ICommentPublicAppService), typeof(CommentPublicClientProxy))]
-    public partial class CommentPublicClientProxy : ClientProxyBase<ICommentPublicAppService>, ICommentPublicAppService
+    public virtual async Task<ListResultDto<CommentWithDetailsDto>> GetListAsync(string entityType, string entityId)
     {
-        public virtual async Task<ListResultDto<CommentWithDetailsDto>> GetListAsync(string entityType, string entityId)
+        return await RequestAsync<ListResultDto<CommentWithDetailsDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ListResultDto<CommentWithDetailsDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(string), entityId }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(string), entityId }
+        });
+    }
 
-        public virtual async Task<CommentDto> CreateAsync(string entityType, string entityId, CreateCommentInput input)
+    public virtual async Task<CommentDto> CreateAsync(string entityType, string entityId, CreateCommentInput input)
+    {
+        return await RequestAsync<CommentDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<CommentDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(string), entityId },
-                { typeof(CreateCommentInput), input }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(string), entityId },
+            { typeof(CreateCommentInput), input }
+        });
+    }
 
-        public virtual async Task<CommentDto> UpdateAsync(Guid id, UpdateCommentInput input)
+    public virtual async Task<CommentDto> UpdateAsync(Guid id, UpdateCommentInput input)
+    {
+        return await RequestAsync<CommentDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<CommentDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(UpdateCommentInput), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(UpdateCommentInput), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Public.HttpApi.Client/ClientProxies/MenuItemPublicClientProxy.Generated.cs

@@ -11,15 +11,14 @@ using System.Collections.Generic;
 using Volo.CmsKit.Menus;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Public.Menus.ClientProxies
+namespace Volo.CmsKit.Public.Menus.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IMenuItemPublicAppService), typeof(MenuItemPublicClientProxy))]
+public partial class MenuItemPublicClientProxy : ClientProxyBase<IMenuItemPublicAppService>, IMenuItemPublicAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IMenuItemPublicAppService), typeof(MenuItemPublicClientProxy))]
-    public partial class MenuItemPublicClientProxy : ClientProxyBase<IMenuItemPublicAppService>, IMenuItemPublicAppService
+    public virtual async Task<List<MenuItemDto>> GetListAsync()
     {
-        public virtual async Task<List<MenuItemDto>> GetListAsync()
-        {
-            return await RequestAsync<List<MenuItemDto>>(nameof(GetListAsync));
-        }
+        return await RequestAsync<List<MenuItemDto>>(nameof(GetListAsync));
     }
 }

modules/cms-kit/src/Volo.CmsKit.Public.HttpApi.Client/ClientProxies/PagesPublicClientProxy.Generated.cs

@@ -9,18 +9,17 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Public.Pages;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Public.Pages.ClientProxies
+namespace Volo.CmsKit.Public.Pages.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IPagePublicAppService), typeof(PagesPublicClientProxy))]
+public partial class PagesPublicClientProxy : ClientProxyBase<IPagePublicAppService>, IPagePublicAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IPagePublicAppService), typeof(PagesPublicClientProxy))]
-    public partial class PagesPublicClientProxy : ClientProxyBase<IPagePublicAppService>, IPagePublicAppService
+    public virtual async Task<PageDto> FindBySlugAsync(string slug)
     {
-        public virtual async Task<PageDto> FindBySlugAsync(string slug)
+        return await RequestAsync<PageDto>(nameof(FindBySlugAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PageDto>(nameof(FindBySlugAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), slug }
-            });
-        }
+            { typeof(string), slug }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Public.HttpApi.Client/ClientProxies/RatingPublicClientProxy.Generated.cs

@@ -10,38 +10,37 @@ using Volo.CmsKit.Public.Ratings;
 using System.Collections.Generic;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Public.Ratings.ClientProxies
+namespace Volo.CmsKit.Public.Ratings.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IRatingPublicAppService), typeof(RatingPublicClientProxy))]
+public partial class RatingPublicClientProxy : ClientProxyBase<IRatingPublicAppService>, IRatingPublicAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IRatingPublicAppService), typeof(RatingPublicClientProxy))]
-    public partial class RatingPublicClientProxy : ClientProxyBase<IRatingPublicAppService>, IRatingPublicAppService
+    public virtual async Task<RatingDto> CreateAsync(string entityType, string entityId, CreateUpdateRatingInput input)
     {
-        public virtual async Task<RatingDto> CreateAsync(string entityType, string entityId, CreateUpdateRatingInput input)
+        return await RequestAsync<RatingDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<RatingDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(string), entityId },
-                { typeof(CreateUpdateRatingInput), input }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(string), entityId },
+            { typeof(CreateUpdateRatingInput), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(string entityType, string entityId)
+    public virtual async Task DeleteAsync(string entityType, string entityId)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(string), entityId }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(string), entityId }
+        });
+    }
 
-        public virtual async Task<List<RatingWithStarCountDto>> GetGroupedStarCountsAsync(string entityType, string entityId)
+    public virtual async Task<List<RatingWithStarCountDto>> GetGroupedStarCountsAsync(string entityType, string entityId)
+    {
+        return await RequestAsync<List<RatingWithStarCountDto>>(nameof(GetGroupedStarCountsAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<List<RatingWithStarCountDto>>(nameof(GetGroupedStarCountsAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(string), entityId }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(string), entityId }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Public.HttpApi.Client/ClientProxies/ReactionPublicClientProxy.Generated.cs

@@ -9,39 +9,38 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.CmsKit.Public.Reactions;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Public.Reactions.ClientProxies
+namespace Volo.CmsKit.Public.Reactions.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IReactionPublicAppService), typeof(ReactionPublicClientProxy))]
+public partial class ReactionPublicClientProxy : ClientProxyBase<IReactionPublicAppService>, IReactionPublicAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IReactionPublicAppService), typeof(ReactionPublicClientProxy))]
-    public partial class ReactionPublicClientProxy : ClientProxyBase<IReactionPublicAppService>, IReactionPublicAppService
+    public virtual async Task<ListResultDto<ReactionWithSelectionDto>> GetForSelectionAsync(string entityType, string entityId)
     {
-        public virtual async Task<ListResultDto<ReactionWithSelectionDto>> GetForSelectionAsync(string entityType, string entityId)
+        return await RequestAsync<ListResultDto<ReactionWithSelectionDto>>(nameof(GetForSelectionAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ListResultDto<ReactionWithSelectionDto>>(nameof(GetForSelectionAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(string), entityId }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(string), entityId }
+        });
+    }
 
-        public virtual async Task CreateAsync(string entityType, string entityId, string reaction)
+    public virtual async Task CreateAsync(string entityType, string entityId, string reaction)
+    {
+        await RequestAsync(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(string), entityId },
-                { typeof(string), reaction }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(string), entityId },
+            { typeof(string), reaction }
+        });
+    }
 
-        public virtual async Task DeleteAsync(string entityType, string entityId, string reaction)
+    public virtual async Task DeleteAsync(string entityType, string entityId, string reaction)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(string), entityId },
-                { typeof(string), reaction }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(string), entityId },
+            { typeof(string), reaction }
+        });
     }
 }

modules/cms-kit/src/Volo.CmsKit.Public.HttpApi.Client/ClientProxies/TagPublicClientProxy.Generated.cs

@@ -10,19 +10,18 @@ using Volo.CmsKit.Tags;
 using System.Collections.Generic;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.CmsKit.Public.Tags.ClientProxies
+namespace Volo.CmsKit.Public.Tags.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(ITagAppService), typeof(TagPublicClientProxy))]
+public partial class TagPublicClientProxy : ClientProxyBase<ITagAppService>, ITagAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(ITagAppService), typeof(TagPublicClientProxy))]
-    public partial class TagPublicClientProxy : ClientProxyBase<ITagAppService>, ITagAppService
+    public virtual async Task<List<TagDto>> GetAllRelatedTagsAsync(string entityType, string entityId)
     {
-        public virtual async Task<List<TagDto>> GetAllRelatedTagsAsync(string entityType, string entityId)
+        return await RequestAsync<List<TagDto>>(nameof(GetAllRelatedTagsAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<List<TagDto>>(nameof(GetAllRelatedTagsAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), entityType },
-                { typeof(string), entityId }
-            });
-        }
+            { typeof(string), entityType },
+            { typeof(string), entityId }
+        });
     }
 }

modules/docs/src/Volo.Docs.Admin.HttpApi.Client/ClientProxies/DocumentsAdminClientProxy.Generated.cs

@@ -9,58 +9,57 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Docs.Admin.Documents;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Docs.Admin.ClientProxies
+namespace Volo.Docs.Admin.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IDocumentAdminAppService), typeof(DocumentsAdminClientProxy))]
+public partial class DocumentsAdminClientProxy : ClientProxyBase<IDocumentAdminAppService>, IDocumentAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IDocumentAdminAppService), typeof(DocumentsAdminClientProxy))]
-    public partial class DocumentsAdminClientProxy : ClientProxyBase<IDocumentAdminAppService>, IDocumentAdminAppService
+    public virtual async Task ClearCacheAsync(ClearCacheInput input)
     {
-        public virtual async Task ClearCacheAsync(ClearCacheInput input)
+        await RequestAsync(nameof(ClearCacheAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(ClearCacheAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(ClearCacheInput), input }
-            });
-        }
+            { typeof(ClearCacheInput), input }
+        });
+    }
 
-        public virtual async Task PullAllAsync(PullAllDocumentInput input)
+    public virtual async Task PullAllAsync(PullAllDocumentInput input)
+    {
+        await RequestAsync(nameof(PullAllAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(PullAllAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(PullAllDocumentInput), input }
-            });
-        }
+            { typeof(PullAllDocumentInput), input }
+        });
+    }
 
-        public virtual async Task PullAsync(PullDocumentInput input)
+    public virtual async Task PullAsync(PullDocumentInput input)
+    {
+        await RequestAsync(nameof(PullAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(PullAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(PullDocumentInput), input }
-            });
-        }
+            { typeof(PullDocumentInput), input }
+        });
+    }
 
-        public virtual async Task<PagedResultDto<DocumentDto>> GetAllAsync(GetAllInput input)
+    public virtual async Task<PagedResultDto<DocumentDto>> GetAllAsync(GetAllInput input)
+    {
+        return await RequestAsync<PagedResultDto<DocumentDto>>(nameof(GetAllAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<DocumentDto>>(nameof(GetAllAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetAllInput), input }
-            });
-        }
+            { typeof(GetAllInput), input }
+        });
+    }
 
-        public virtual async Task RemoveFromCacheAsync(Guid documentId)
+    public virtual async Task RemoveFromCacheAsync(Guid documentId)
+    {
+        await RequestAsync(nameof(RemoveFromCacheAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(RemoveFromCacheAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), documentId }
-            });
-        }
+            { typeof(Guid), documentId }
+        });
+    }
 
-        public virtual async Task ReindexAsync(Guid documentId)
+    public virtual async Task ReindexAsync(Guid documentId)
+    {
+        await RequestAsync(nameof(ReindexAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(ReindexAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), documentId }
-            });
-        }
+            { typeof(Guid), documentId }
+        });
     }
 }

modules/docs/src/Volo.Docs.Admin.HttpApi.Client/ClientProxies/DocumentsAdminClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of DocumentsAdminClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Docs.Admin.ClientProxies
+namespace Volo.Docs.Admin.ClientProxies;
+
+public partial class DocumentsAdminClientProxy
 {
-    public partial class DocumentsAdminClientProxy
-    {
-    }
 }

modules/docs/src/Volo.Docs.Admin.HttpApi.Client/ClientProxies/ProjectsAdminClientProxy.Generated.cs

@@ -9,64 +9,63 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Docs.Admin.Projects;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Docs.Admin.ClientProxies
+namespace Volo.Docs.Admin.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IProjectAdminAppService), typeof(ProjectsAdminClientProxy))]
+public partial class ProjectsAdminClientProxy : ClientProxyBase<IProjectAdminAppService>, IProjectAdminAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IProjectAdminAppService), typeof(ProjectsAdminClientProxy))]
-    public partial class ProjectsAdminClientProxy : ClientProxyBase<IProjectAdminAppService>, IProjectAdminAppService
+    public virtual async Task<PagedResultDto<ProjectDto>> GetListAsync(PagedAndSortedResultRequestDto input)
     {
-        public virtual async Task<PagedResultDto<ProjectDto>> GetListAsync(PagedAndSortedResultRequestDto input)
+        return await RequestAsync<PagedResultDto<ProjectDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<ProjectDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(PagedAndSortedResultRequestDto), input }
-            });
-        }
+            { typeof(PagedAndSortedResultRequestDto), input }
+        });
+    }
 
-        public virtual async Task<ProjectDto> GetAsync(Guid id)
+    public virtual async Task<ProjectDto> GetAsync(Guid id)
+    {
+        return await RequestAsync<ProjectDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ProjectDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<ProjectDto> CreateAsync(CreateProjectDto input)
+    public virtual async Task<ProjectDto> CreateAsync(CreateProjectDto input)
+    {
+        return await RequestAsync<ProjectDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ProjectDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(CreateProjectDto), input }
-            });
-        }
+            { typeof(CreateProjectDto), input }
+        });
+    }
 
-        public virtual async Task<ProjectDto> UpdateAsync(Guid id, UpdateProjectDto input)
+    public virtual async Task<ProjectDto> UpdateAsync(Guid id, UpdateProjectDto input)
+    {
+        return await RequestAsync<ProjectDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ProjectDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(UpdateProjectDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(UpdateProjectDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task ReindexAllAsync()
-        {
-            await RequestAsync(nameof(ReindexAllAsync));
-        }
+    public virtual async Task ReindexAllAsync()
+    {
+        await RequestAsync(nameof(ReindexAllAsync));
+    }
 
-        public virtual async Task ReindexAsync(ReindexInput input)
+    public virtual async Task ReindexAsync(ReindexInput input)
+    {
+        await RequestAsync(nameof(ReindexAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(ReindexAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(ReindexInput), input }
-            });
-        }
+            { typeof(ReindexInput), input }
+        });
     }
 }

modules/docs/src/Volo.Docs.Admin.HttpApi.Client/ClientProxies/ProjectsAdminClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of ProjectsAdminClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Docs.Admin.ClientProxies
+namespace Volo.Docs.Admin.ClientProxies;
+
+public partial class ProjectsAdminClientProxy
 {
-    public partial class ProjectsAdminClientProxy
-    {
-    }
 }

modules/docs/src/Volo.Docs.HttpApi.Client/ClientProxies/DocsDocumentClientProxy.Generated.cs

@@ -10,71 +10,70 @@ using Volo.Docs.Documents;
 using System.Collections.Generic;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Docs.Documents.ClientProxies
+namespace Volo.Docs.Documents.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IDocumentAppService), typeof(DocsDocumentClientProxy))]
+public partial class DocsDocumentClientProxy : ClientProxyBase<IDocumentAppService>, IDocumentAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IDocumentAppService), typeof(DocsDocumentClientProxy))]
-    public partial class DocsDocumentClientProxy : ClientProxyBase<IDocumentAppService>, IDocumentAppService
+    public virtual async Task<DocumentWithDetailsDto> GetAsync(GetDocumentInput input)
     {
-        public virtual async Task<DocumentWithDetailsDto> GetAsync(GetDocumentInput input)
+        return await RequestAsync<DocumentWithDetailsDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<DocumentWithDetailsDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetDocumentInput), input }
-            });
-        }
+            { typeof(GetDocumentInput), input }
+        });
+    }
 
-        public virtual async Task<DocumentWithDetailsDto> GetDefaultAsync(GetDefaultDocumentInput input)
+    public virtual async Task<DocumentWithDetailsDto> GetDefaultAsync(GetDefaultDocumentInput input)
+    {
+        return await RequestAsync<DocumentWithDetailsDto>(nameof(GetDefaultAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<DocumentWithDetailsDto>(nameof(GetDefaultAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetDefaultDocumentInput), input }
-            });
-        }
+            { typeof(GetDefaultDocumentInput), input }
+        });
+    }
 
-        public virtual async Task<NavigationNode> GetNavigationAsync(GetNavigationDocumentInput input)
+    public virtual async Task<NavigationNode> GetNavigationAsync(GetNavigationDocumentInput input)
+    {
+        return await RequestAsync<NavigationNode>(nameof(GetNavigationAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<NavigationNode>(nameof(GetNavigationAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetNavigationDocumentInput), input }
-            });
-        }
+            { typeof(GetNavigationDocumentInput), input }
+        });
+    }
 
-        public virtual async Task<DocumentResourceDto> GetResourceAsync(GetDocumentResourceInput input)
+    public virtual async Task<DocumentResourceDto> GetResourceAsync(GetDocumentResourceInput input)
+    {
+        return await RequestAsync<DocumentResourceDto>(nameof(GetResourceAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<DocumentResourceDto>(nameof(GetResourceAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetDocumentResourceInput), input }
-            });
-        }
+            { typeof(GetDocumentResourceInput), input }
+        });
+    }
 
-        public virtual async Task<List<DocumentSearchOutput>> SearchAsync(DocumentSearchInput input)
+    public virtual async Task<List<DocumentSearchOutput>> SearchAsync(DocumentSearchInput input)
+    {
+        return await RequestAsync<List<DocumentSearchOutput>>(nameof(SearchAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<List<DocumentSearchOutput>>(nameof(SearchAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(DocumentSearchInput), input }
-            });
-        }
+            { typeof(DocumentSearchInput), input }
+        });
+    }
 
-        public virtual async Task<bool> FullSearchEnabledAsync()
-        {
-            return await RequestAsync<bool>(nameof(FullSearchEnabledAsync));
-        }
+    public virtual async Task<bool> FullSearchEnabledAsync()
+    {
+        return await RequestAsync<bool>(nameof(FullSearchEnabledAsync));
+    }
 
-        public virtual async Task<List<String>> GetUrlsAsync(string prefix)
+    public virtual async Task<List<String>> GetUrlsAsync(string prefix)
+    {
+        return await RequestAsync<List<String>>(nameof(GetUrlsAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<List<String>>(nameof(GetUrlsAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), prefix }
-            });
-        }
+            { typeof(string), prefix }
+        });
+    }
 
-        public virtual async Task<DocumentParametersDto> GetParametersAsync(GetParametersDocumentInput input)
+    public virtual async Task<DocumentParametersDto> GetParametersAsync(GetParametersDocumentInput input)
+    {
+        return await RequestAsync<DocumentParametersDto>(nameof(GetParametersAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<DocumentParametersDto>(nameof(GetParametersAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetParametersDocumentInput), input }
-            });
-        }
+            { typeof(GetParametersDocumentInput), input }
+        });
     }
 }

modules/docs/src/Volo.Docs.HttpApi.Client/ClientProxies/DocsDocumentClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of DocsDocumentClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Docs.Documents.ClientProxies
+namespace Volo.Docs.Documents.ClientProxies;
+
+public partial class DocsDocumentClientProxy
 {
-    public partial class DocsDocumentClientProxy
-    {
-    }
 }

modules/docs/src/Volo.Docs.HttpApi.Client/ClientProxies/DocsProjectClientProxy.Generated.cs

@@ -10,49 +10,48 @@ using Volo.Docs.Projects;
 using Volo.Docs.Documents;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Docs.Projects.ClientProxies
+namespace Volo.Docs.Projects.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IProjectAppService), typeof(DocsProjectClientProxy))]
+public partial class DocsProjectClientProxy : ClientProxyBase<IProjectAppService>, IProjectAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IProjectAppService), typeof(DocsProjectClientProxy))]
-    public partial class DocsProjectClientProxy : ClientProxyBase<IProjectAppService>, IProjectAppService
+    public virtual async Task<ListResultDto<ProjectDto>> GetListAsync()
     {
-        public virtual async Task<ListResultDto<ProjectDto>> GetListAsync()
-        {
-            return await RequestAsync<ListResultDto<ProjectDto>>(nameof(GetListAsync));
-        }
+        return await RequestAsync<ListResultDto<ProjectDto>>(nameof(GetListAsync));
+    }
 
-        public virtual async Task<ProjectDto> GetAsync(string shortName)
+    public virtual async Task<ProjectDto> GetAsync(string shortName)
+    {
+        return await RequestAsync<ProjectDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ProjectDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), shortName }
-            });
-        }
+            { typeof(string), shortName }
+        });
+    }
 
-        public virtual async Task<string> GetDefaultLanguageCodeAsync(string shortName, string version)
+    public virtual async Task<string> GetDefaultLanguageCodeAsync(string shortName, string version)
+    {
+        return await RequestAsync<string>(nameof(GetDefaultLanguageCodeAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<string>(nameof(GetDefaultLanguageCodeAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), shortName },
-                { typeof(string), version }
-            });
-        }
+            { typeof(string), shortName },
+            { typeof(string), version }
+        });
+    }
 
-        public virtual async Task<ListResultDto<VersionInfoDto>> GetVersionsAsync(string shortName)
+    public virtual async Task<ListResultDto<VersionInfoDto>> GetVersionsAsync(string shortName)
+    {
+        return await RequestAsync<ListResultDto<VersionInfoDto>>(nameof(GetVersionsAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ListResultDto<VersionInfoDto>>(nameof(GetVersionsAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), shortName }
-            });
-        }
+            { typeof(string), shortName }
+        });
+    }
 
-        public virtual async Task<LanguageConfig> GetLanguageListAsync(string shortName, string version)
+    public virtual async Task<LanguageConfig> GetLanguageListAsync(string shortName, string version)
+    {
+        return await RequestAsync<LanguageConfig>(nameof(GetLanguageListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<LanguageConfig>(nameof(GetLanguageListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), shortName },
-                { typeof(string), version }
-            });
-        }
+            { typeof(string), shortName },
+            { typeof(string), version }
+        });
     }
 }

modules/docs/src/Volo.Docs.HttpApi.Client/ClientProxies/DocsProjectClientProxy.cs

@@ -1,8 +1,7 @@
 // This file is part of DocsProjectClientProxy, you can customize it here
 // ReSharper disable once CheckNamespace
-namespace Volo.Docs.Projects.ClientProxies
+namespace Volo.Docs.Projects.ClientProxies;
+
+public partial class DocsProjectClientProxy
 {
-    public partial class DocsProjectClientProxy
-    {
-    }
 }

modules/feature-management/src/Volo.Abp.FeatureManagement.HttpApi.Client/ClientProxies/FeaturesClientProxy.Generated.cs

@@ -9,29 +9,28 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Abp.FeatureManagement;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.FeatureManagement.ClientProxies
+namespace Volo.Abp.FeatureManagement.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IFeatureAppService), typeof(FeaturesClientProxy))]
+public partial class FeaturesClientProxy : ClientProxyBase<IFeatureAppService>, IFeatureAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IFeatureAppService), typeof(FeaturesClientProxy))]
-    public partial class FeaturesClientProxy : ClientProxyBase<IFeatureAppService>, IFeatureAppService
+    public virtual async Task<GetFeatureListResultDto> GetAsync(string providerName, string providerKey)
     {
-        public virtual async Task<GetFeatureListResultDto> GetAsync(string providerName, string providerKey)
+        return await RequestAsync<GetFeatureListResultDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<GetFeatureListResultDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), providerName },
-                { typeof(string), providerKey }
-            });
-        }
+            { typeof(string), providerName },
+            { typeof(string), providerKey }
+        });
+    }
 
-        public virtual async Task UpdateAsync(string providerName, string providerKey, UpdateFeaturesDto input)
+    public virtual async Task UpdateAsync(string providerName, string providerKey, UpdateFeaturesDto input)
+    {
+        await RequestAsync(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), providerName },
-                { typeof(string), providerKey },
-                { typeof(UpdateFeaturesDto), input }
-            });
-        }
+            { typeof(string), providerName },
+            { typeof(string), providerKey },
+            { typeof(UpdateFeaturesDto), input }
+        });
     }
 }

modules/identity/src/Volo.Abp.Identity.HttpApi.Client/ClientProxies/IdentityRoleClientProxy.Generated.cs

@@ -9,56 +9,55 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Abp.Identity;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.Identity.ClientProxies
+namespace Volo.Abp.Identity.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IIdentityRoleAppService), typeof(IdentityRoleClientProxy))]
+public partial class IdentityRoleClientProxy : ClientProxyBase<IIdentityRoleAppService>, IIdentityRoleAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IIdentityRoleAppService), typeof(IdentityRoleClientProxy))]
-    public partial class IdentityRoleClientProxy : ClientProxyBase<IIdentityRoleAppService>, IIdentityRoleAppService
+    public virtual async Task<ListResultDto<IdentityRoleDto>> GetAllListAsync()
     {
-        public virtual async Task<ListResultDto<IdentityRoleDto>> GetAllListAsync()
-        {
-            return await RequestAsync<ListResultDto<IdentityRoleDto>>(nameof(GetAllListAsync));
-        }
+        return await RequestAsync<ListResultDto<IdentityRoleDto>>(nameof(GetAllListAsync));
+    }
 
-        public virtual async Task<PagedResultDto<IdentityRoleDto>> GetListAsync(GetIdentityRolesInput input)
+    public virtual async Task<PagedResultDto<IdentityRoleDto>> GetListAsync(GetIdentityRolesInput input)
+    {
+        return await RequestAsync<PagedResultDto<IdentityRoleDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<IdentityRoleDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetIdentityRolesInput), input }
-            });
-        }
+            { typeof(GetIdentityRolesInput), input }
+        });
+    }
 
-        public virtual async Task<IdentityRoleDto> GetAsync(Guid id)
+    public virtual async Task<IdentityRoleDto> GetAsync(Guid id)
+    {
+        return await RequestAsync<IdentityRoleDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IdentityRoleDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<IdentityRoleDto> CreateAsync(IdentityRoleCreateDto input)
+    public virtual async Task<IdentityRoleDto> CreateAsync(IdentityRoleCreateDto input)
+    {
+        return await RequestAsync<IdentityRoleDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IdentityRoleDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(IdentityRoleCreateDto), input }
-            });
-        }
+            { typeof(IdentityRoleCreateDto), input }
+        });
+    }
 
-        public virtual async Task<IdentityRoleDto> UpdateAsync(Guid id, IdentityRoleUpdateDto input)
+    public virtual async Task<IdentityRoleDto> UpdateAsync(Guid id, IdentityRoleUpdateDto input)
+    {
+        return await RequestAsync<IdentityRoleDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IdentityRoleDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(IdentityRoleUpdateDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(IdentityRoleUpdateDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }

modules/identity/src/Volo.Abp.Identity.HttpApi.Client/ClientProxies/IdentityUserClientProxy.Generated.cs

@@ -9,89 +9,88 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Abp.Identity;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.Identity.ClientProxies
+namespace Volo.Abp.Identity.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IIdentityUserAppService), typeof(IdentityUserClientProxy))]
+public partial class IdentityUserClientProxy : ClientProxyBase<IIdentityUserAppService>, IIdentityUserAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IIdentityUserAppService), typeof(IdentityUserClientProxy))]
-    public partial class IdentityUserClientProxy : ClientProxyBase<IIdentityUserAppService>, IIdentityUserAppService
+    public virtual async Task<IdentityUserDto> GetAsync(Guid id)
     {
-        public virtual async Task<IdentityUserDto> GetAsync(Guid id)
+        return await RequestAsync<IdentityUserDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IdentityUserDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<PagedResultDto<IdentityUserDto>> GetListAsync(GetIdentityUsersInput input)
+    public virtual async Task<PagedResultDto<IdentityUserDto>> GetListAsync(GetIdentityUsersInput input)
+    {
+        return await RequestAsync<PagedResultDto<IdentityUserDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<IdentityUserDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetIdentityUsersInput), input }
-            });
-        }
+            { typeof(GetIdentityUsersInput), input }
+        });
+    }
 
-        public virtual async Task<IdentityUserDto> CreateAsync(IdentityUserCreateDto input)
+    public virtual async Task<IdentityUserDto> CreateAsync(IdentityUserCreateDto input)
+    {
+        return await RequestAsync<IdentityUserDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IdentityUserDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(IdentityUserCreateDto), input }
-            });
-        }
+            { typeof(IdentityUserCreateDto), input }
+        });
+    }
 
-        public virtual async Task<IdentityUserDto> UpdateAsync(Guid id, IdentityUserUpdateDto input)
+    public virtual async Task<IdentityUserDto> UpdateAsync(Guid id, IdentityUserUpdateDto input)
+    {
+        return await RequestAsync<IdentityUserDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IdentityUserDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(IdentityUserUpdateDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(IdentityUserUpdateDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<ListResultDto<IdentityRoleDto>> GetRolesAsync(Guid id)
+    public virtual async Task<ListResultDto<IdentityRoleDto>> GetRolesAsync(Guid id)
+    {
+        return await RequestAsync<ListResultDto<IdentityRoleDto>>(nameof(GetRolesAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ListResultDto<IdentityRoleDto>>(nameof(GetRolesAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<ListResultDto<IdentityRoleDto>> GetAssignableRolesAsync()
-        {
-            return await RequestAsync<ListResultDto<IdentityRoleDto>>(nameof(GetAssignableRolesAsync));
-        }
+    public virtual async Task<ListResultDto<IdentityRoleDto>> GetAssignableRolesAsync()
+    {
+        return await RequestAsync<ListResultDto<IdentityRoleDto>>(nameof(GetAssignableRolesAsync));
+    }
 
-        public virtual async Task UpdateRolesAsync(Guid id, IdentityUserUpdateRolesDto input)
+    public virtual async Task UpdateRolesAsync(Guid id, IdentityUserUpdateRolesDto input)
+    {
+        await RequestAsync(nameof(UpdateRolesAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(UpdateRolesAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(IdentityUserUpdateRolesDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(IdentityUserUpdateRolesDto), input }
+        });
+    }
 
-        public virtual async Task<IdentityUserDto> FindByUsernameAsync(string userName)
+    public virtual async Task<IdentityUserDto> FindByUsernameAsync(string userName)
+    {
+        return await RequestAsync<IdentityUserDto>(nameof(FindByUsernameAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IdentityUserDto>(nameof(FindByUsernameAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), userName }
-            });
-        }
+            { typeof(string), userName }
+        });
+    }
 
-        public virtual async Task<IdentityUserDto> FindByEmailAsync(string email)
+    public virtual async Task<IdentityUserDto> FindByEmailAsync(string email)
+    {
+        return await RequestAsync<IdentityUserDto>(nameof(FindByEmailAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<IdentityUserDto>(nameof(FindByEmailAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), email }
-            });
-        }
+            { typeof(string), email }
+        });
     }
 }

modules/identity/src/Volo.Abp.Identity.HttpApi.Client/ClientProxies/IdentityUserLookupClientProxy.Generated.cs

@@ -10,42 +10,41 @@ using Volo.Abp.Identity;
 using Volo.Abp.Users;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.Identity.ClientProxies
+namespace Volo.Abp.Identity.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IIdentityUserLookupAppService), typeof(IdentityUserLookupClientProxy))]
+public partial class IdentityUserLookupClientProxy : ClientProxyBase<IIdentityUserLookupAppService>, IIdentityUserLookupAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IIdentityUserLookupAppService), typeof(IdentityUserLookupClientProxy))]
-    public partial class IdentityUserLookupClientProxy : ClientProxyBase<IIdentityUserLookupAppService>, IIdentityUserLookupAppService
+    public virtual async Task<UserData> FindByIdAsync(Guid id)
     {
-        public virtual async Task<UserData> FindByIdAsync(Guid id)
+        return await RequestAsync<UserData>(nameof(FindByIdAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<UserData>(nameof(FindByIdAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<UserData> FindByUserNameAsync(string userName)
+    public virtual async Task<UserData> FindByUserNameAsync(string userName)
+    {
+        return await RequestAsync<UserData>(nameof(FindByUserNameAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<UserData>(nameof(FindByUserNameAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), userName }
-            });
-        }
+            { typeof(string), userName }
+        });
+    }
 
-        public virtual async Task<ListResultDto<UserData>> SearchAsync(UserLookupSearchInputDto input)
+    public virtual async Task<ListResultDto<UserData>> SearchAsync(UserLookupSearchInputDto input)
+    {
+        return await RequestAsync<ListResultDto<UserData>>(nameof(SearchAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<ListResultDto<UserData>>(nameof(SearchAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(UserLookupSearchInputDto), input }
-            });
-        }
+            { typeof(UserLookupSearchInputDto), input }
+        });
+    }
 
-        public virtual async Task<long> GetCountAsync(UserLookupCountInputDto input)
+    public virtual async Task<long> GetCountAsync(UserLookupCountInputDto input)
+    {
+        return await RequestAsync<long>(nameof(GetCountAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<long>(nameof(GetCountAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(UserLookupCountInputDto), input }
-            });
-        }
+            { typeof(UserLookupCountInputDto), input }
+        });
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.HttpApi.Client/ClientProxies/PermissionsClientProxy.Generated.cs

@@ -9,29 +9,28 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Abp.PermissionManagement;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.PermissionManagement.ClientProxies
+namespace Volo.Abp.PermissionManagement.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IPermissionAppService), typeof(PermissionsClientProxy))]
+public partial class PermissionsClientProxy : ClientProxyBase<IPermissionAppService>, IPermissionAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IPermissionAppService), typeof(PermissionsClientProxy))]
-    public partial class PermissionsClientProxy : ClientProxyBase<IPermissionAppService>, IPermissionAppService
+    public virtual async Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
     {
-        public virtual async Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
+        return await RequestAsync<GetPermissionListResultDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<GetPermissionListResultDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), providerName },
-                { typeof(string), providerKey }
-            });
-        }
+            { typeof(string), providerName },
+            { typeof(string), providerKey }
+        });
+    }
 
-        public virtual async Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)
+    public virtual async Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)
+    {
+        await RequestAsync(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(string), providerName },
-                { typeof(string), providerKey },
-                { typeof(UpdatePermissionsDto), input }
-            });
-        }
+            { typeof(string), providerName },
+            { typeof(string), providerKey },
+            { typeof(UpdatePermissionsDto), input }
+        });
     }
 }

modules/setting-management/src/Volo.Abp.SettingManagement.HttpApi.Client/ClientProxies/EmailSettingsClientProxy.Generated.cs

@@ -9,23 +9,22 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Abp.SettingManagement;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.SettingManagement.ClientProxies
+namespace Volo.Abp.SettingManagement.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IEmailSettingsAppService), typeof(EmailSettingsClientProxy))]
+public partial class EmailSettingsClientProxy : ClientProxyBase<IEmailSettingsAppService>, IEmailSettingsAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(IEmailSettingsAppService), typeof(EmailSettingsClientProxy))]
-    public partial class EmailSettingsClientProxy : ClientProxyBase<IEmailSettingsAppService>, IEmailSettingsAppService
+    public virtual async Task<EmailSettingsDto> GetAsync()
     {
-        public virtual async Task<EmailSettingsDto> GetAsync()
-        {
-            return await RequestAsync<EmailSettingsDto>(nameof(GetAsync));
-        }
+        return await RequestAsync<EmailSettingsDto>(nameof(GetAsync));
+    }
 
-        public virtual async Task UpdateAsync(UpdateEmailSettingsDto input)
+    public virtual async Task UpdateAsync(UpdateEmailSettingsDto input)
+    {
+        await RequestAsync(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(UpdateEmailSettingsDto), input }
-            });
-        }
+            { typeof(UpdateEmailSettingsDto), input }
+        });
     }
 }

modules/tenant-management/src/Volo.Abp.TenantManagement.HttpApi.Client/ClientProxies/TenantClientProxy.Generated.cs

@@ -9,76 +9,75 @@ using Volo.Abp.Http.Client.ClientProxying;
 using Volo.Abp.TenantManagement;
 
 // ReSharper disable once CheckNamespace
-namespace Volo.Abp.TenantManagement.ClientProxies
+namespace Volo.Abp.TenantManagement.ClientProxies;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(ITenantAppService), typeof(TenantClientProxy))]
+public partial class TenantClientProxy : ClientProxyBase<ITenantAppService>, ITenantAppService
 {
-    [Dependency(ReplaceServices = true)]
-    [ExposeServices(typeof(ITenantAppService), typeof(TenantClientProxy))]
-    public partial class TenantClientProxy : ClientProxyBase<ITenantAppService>, ITenantAppService
+    public virtual async Task<TenantDto> GetAsync(Guid id)
     {
-        public virtual async Task<TenantDto> GetAsync(Guid id)
+        return await RequestAsync<TenantDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<TenantDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<PagedResultDto<TenantDto>> GetListAsync(GetTenantsInput input)
+    public virtual async Task<PagedResultDto<TenantDto>> GetListAsync(GetTenantsInput input)
+    {
+        return await RequestAsync<PagedResultDto<TenantDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<PagedResultDto<TenantDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(GetTenantsInput), input }
-            });
-        }
+            { typeof(GetTenantsInput), input }
+        });
+    }
 
-        public virtual async Task<TenantDto> CreateAsync(TenantCreateDto input)
+    public virtual async Task<TenantDto> CreateAsync(TenantCreateDto input)
+    {
+        return await RequestAsync<TenantDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<TenantDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(TenantCreateDto), input }
-            });
-        }
+            { typeof(TenantCreateDto), input }
+        });
+    }
 
-        public virtual async Task<TenantDto> UpdateAsync(Guid id, TenantUpdateDto input)
+    public virtual async Task<TenantDto> UpdateAsync(Guid id, TenantUpdateDto input)
+    {
+        return await RequestAsync<TenantDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<TenantDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(TenantUpdateDto), input }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(TenantUpdateDto), input }
+        });
+    }
 
-        public virtual async Task DeleteAsync(Guid id)
+    public virtual async Task DeleteAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task<string> GetDefaultConnectionStringAsync(Guid id)
+    public virtual async Task<string> GetDefaultConnectionStringAsync(Guid id)
+    {
+        return await RequestAsync<string>(nameof(GetDefaultConnectionStringAsync), new ClientProxyRequestTypeValue
         {
-            return await RequestAsync<string>(nameof(GetDefaultConnectionStringAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
+    }
 
-        public virtual async Task UpdateDefaultConnectionStringAsync(Guid id, string defaultConnectionString)
+    public virtual async Task UpdateDefaultConnectionStringAsync(Guid id, string defaultConnectionString)
+    {
+        await RequestAsync(nameof(UpdateDefaultConnectionStringAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(UpdateDefaultConnectionStringAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id },
-                { typeof(string), defaultConnectionString }
-            });
-        }
+            { typeof(Guid), id },
+            { typeof(string), defaultConnectionString }
+        });
+    }
 
-        public virtual async Task DeleteDefaultConnectionStringAsync(Guid id)
+    public virtual async Task DeleteDefaultConnectionStringAsync(Guid id)
+    {
+        await RequestAsync(nameof(DeleteDefaultConnectionStringAsync), new ClientProxyRequestTypeValue
         {
-            await RequestAsync(nameof(DeleteDefaultConnectionStringAsync), new ClientProxyRequestTypeValue
-            {
-                { typeof(Guid), id }
-            });
-        }
+            { typeof(Guid), id }
+        });
     }
 }