Refactor the proxy class.

framework/src/Volo.Abp.Http.Client/Volo/Abp/Http/Client/ClientProxying/ClientProxyBase.cs

@@ -38,19 +38,24 @@ namespace Volo.Abp.Http.Client.ClientProxying
         protected ClientProxyRequestPayloadBuilder ClientProxyRequestPayloadBuilder  => LazyServiceProvider.LazyGetRequiredService<ClientProxyRequestPayloadBuilder>();
         protected ClientProxyUrlBuilder ClientProxyUrlBuilder  => LazyServiceProvider.LazyGetRequiredService<ClientProxyUrlBuilder>();
 
-        protected virtual async Task RequestAsync(string methodName, params object[] arguments)
+        protected virtual async Task RequestAsync(string methodName, ClientProxyRequestTypeValue arguments = null)
         {
             await RequestAsync(BuildHttpProxyClientProxyContext(methodName, arguments));
         }
 
-        protected virtual async Task<T> RequestAsync<T>(string methodName, params object[] arguments)
+        protected virtual async Task<T> RequestAsync<T>(string methodName, ClientProxyRequestTypeValue arguments = null)
         {
             return await RequestAsync<T>(BuildHttpProxyClientProxyContext(methodName, arguments));
         }
 
-        protected virtual ClientProxyRequestContext BuildHttpProxyClientProxyContext(string methodName, params object[] arguments)
+        protected virtual ClientProxyRequestContext BuildHttpProxyClientProxyContext(string methodName, ClientProxyRequestTypeValue arguments = null)
         {
-            var methodUniqueName = $"{typeof(TService).FullName}.{methodName}.{string.Join("-", arguments.Select(x => x.GetType().FullName))}";
+            if (arguments == null)
+            {
+                arguments = new ClientProxyRequestTypeValue();
+            }
+
+            var methodUniqueName = $"{typeof(TService).FullName}.{methodName}.{string.Join("-", arguments.Select(x => x.Key.FullName))}";
             var action = ClientProxyApiDescriptionFinder.FindAction(methodUniqueName);
             if (action == null)
             {
@@ -60,7 +65,7 @@ namespace Volo.Abp.Http.Client.ClientProxying
                 action,
                 action.Parameters
                     .GroupBy(x => x.NameOnMethod)
-                    .Select((x, i) => new KeyValuePair<string, object>(x.Key, arguments[i]))
+                    .Select((x, i) => new KeyValuePair<string, object>(x.Key, arguments.Values.Skip(i).Take(1)))
                     .ToDictionary(x => x.Key, x => x.Value),
                 typeof(TService));
         }

framework/src/Volo.Abp.Http.Client/Volo/Abp/Http/Client/ClientProxying/ClientProxyRequestTypeValue.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Volo.Abp.Http.Client.ClientProxying
+{
+    public class ClientProxyRequestTypeValue : Dictionary<Type, object>
+    {
+
+    }
+}

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

@@ -18,17 +18,26 @@ namespace Volo.Abp.Account.ClientProxies
     {
         public virtual async Task<IdentityUserDto> RegisterAsync(RegisterDto input)
         {
-            return await RequestAsync<IdentityUserDto>(nameof(RegisterAsync), input);
+            return await RequestAsync<IdentityUserDto>(nameof(RegisterAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(RegisterDto), input }
+            });
         }
 
         public virtual async Task SendPasswordResetCodeAsync(SendPasswordResetCodeDto input)
         {
-            await RequestAsync(nameof(SendPasswordResetCodeAsync), input);
+            await RequestAsync(nameof(SendPasswordResetCodeAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(SendPasswordResetCodeDto), input }
+            });
         }
 
         public virtual async Task ResetPasswordAsync(ResetPasswordDto input)
         {
-            await RequestAsync(nameof(ResetPasswordAsync), input);
+            await RequestAsync(nameof(ResetPasswordAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(ResetPasswordDto), input }
+            });
         }
     }
 }

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

@@ -23,27 +23,43 @@ namespace Volo.Blogging.Admin.ClientProxies
 
         public virtual async Task<BlogDto> GetAsync(Guid id)
         {
-            return await RequestAsync<BlogDto>(nameof(GetAsync), id);
+            return await RequestAsync<BlogDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<BlogDto> CreateAsync(CreateBlogDto input)
         {
-            return await RequestAsync<BlogDto>(nameof(CreateAsync), input);
+            return await RequestAsync<BlogDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(CreateBlogDto), input }
+            });
         }
 
         public virtual async Task<BlogDto> UpdateAsync(Guid id, UpdateBlogDto input)
         {
-            return await RequestAsync<BlogDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<BlogDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(UpdateBlogDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task ClearCacheAsync(Guid id)
         {
-            await RequestAsync(nameof(ClearCacheAsync), id);
+            await RequestAsync(nameof(ClearCacheAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -17,12 +17,18 @@ namespace Volo.Blogging.ClientProxies
     {
         public virtual async Task<RawFileDto> GetAsync(string name)
         {
-            return await RequestAsync<RawFileDto>(nameof(GetAsync), name);
+            return await RequestAsync<RawFileDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), name }
+            });
         }
 
         public virtual async Task<FileUploadOutputDto> CreateAsync(FileUploadInputDto input)
         {
-            return await RequestAsync<FileUploadOutputDto>(nameof(CreateAsync), input);
+            return await RequestAsync<FileUploadOutputDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(FileUploadInputDto), input }
+            });
         }
     }
 }

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

@@ -23,12 +23,18 @@ namespace Volo.Blogging.ClientProxies
 
         public virtual async Task<BlogDto> GetByShortNameAsync(string shortName)
         {
-            return await RequestAsync<BlogDto>(nameof(GetByShortNameAsync), shortName);
+            return await RequestAsync<BlogDto>(nameof(GetByShortNameAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), shortName }
+            });
         }
 
         public virtual async Task<BlogDto> GetAsync(Guid id)
         {
-            return await RequestAsync<BlogDto>(nameof(GetAsync), id);
+            return await RequestAsync<BlogDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -19,22 +19,35 @@ namespace Volo.Blogging.ClientProxies
     {
         public virtual async Task<List<CommentWithRepliesDto>> GetHierarchicalListOfPostAsync(Guid postId)
         {
-            return await RequestAsync<List<CommentWithRepliesDto>>(nameof(GetHierarchicalListOfPostAsync), postId);
+            return await RequestAsync<List<CommentWithRepliesDto>>(nameof(GetHierarchicalListOfPostAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), postId }
+            });
         }
 
         public virtual async Task<CommentWithDetailsDto> CreateAsync(CreateCommentDto input)
         {
-            return await RequestAsync<CommentWithDetailsDto>(nameof(CreateAsync), input);
+            return await RequestAsync<CommentWithDetailsDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(CreateCommentDto), input }
+            });
         }
 
         public virtual async Task<CommentWithDetailsDto> UpdateAsync(Guid id, UpdateCommentDto input)
         {
-            return await RequestAsync<CommentWithDetailsDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<CommentWithDetailsDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(UpdateCommentDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -17,37 +17,60 @@ namespace Volo.Blogging.ClientProxies
     {
         public virtual async Task<ListResultDto<PostWithDetailsDto>> GetListByBlogIdAndTagNameAsync(Guid blogId, string tagName)
         {
-            return await RequestAsync<ListResultDto<PostWithDetailsDto>>(nameof(GetListByBlogIdAndTagNameAsync), blogId, tagName);
+            return await RequestAsync<ListResultDto<PostWithDetailsDto>>(nameof(GetListByBlogIdAndTagNameAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), blogId },
+                { typeof(string), tagName }
+            });
         }
 
         public virtual async Task<ListResultDto<PostWithDetailsDto>> GetTimeOrderedListAsync(Guid blogId)
         {
-            return await RequestAsync<ListResultDto<PostWithDetailsDto>>(nameof(GetTimeOrderedListAsync), blogId);
+            return await RequestAsync<ListResultDto<PostWithDetailsDto>>(nameof(GetTimeOrderedListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), blogId }
+            });
         }
 
         public virtual async Task<PostWithDetailsDto> GetForReadingAsync(GetPostInput input)
         {
-            return await RequestAsync<PostWithDetailsDto>(nameof(GetForReadingAsync), input);
+            return await RequestAsync<PostWithDetailsDto>(nameof(GetForReadingAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetPostInput), input }
+            });
         }
 
         public virtual async Task<PostWithDetailsDto> GetAsync(Guid id)
         {
-            return await RequestAsync<PostWithDetailsDto>(nameof(GetAsync), id);
+            return await RequestAsync<PostWithDetailsDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<PostWithDetailsDto> CreateAsync(CreatePostDto input)
         {
-            return await RequestAsync<PostWithDetailsDto>(nameof(CreateAsync), input);
+            return await RequestAsync<PostWithDetailsDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(CreatePostDto), input }
+            });
         }
 
         public virtual async Task<PostWithDetailsDto> UpdateAsync(Guid id, UpdatePostDto input)
         {
-            return await RequestAsync<PostWithDetailsDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<PostWithDetailsDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(UpdatePostDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -19,7 +19,11 @@ namespace Volo.Blogging.ClientProxies
     {
         public virtual async Task<List<TagDto>> GetPopularTagsAsync(Guid blogId, GetPopularTagsInput input)
         {
-            return await RequestAsync<List<TagDto>>(nameof(GetPopularTagsAsync), blogId, input);
+            return await RequestAsync<List<TagDto>>(nameof(GetPopularTagsAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), blogId },
+                { typeof(GetPopularTagsInput), input }
+            });
         }
     }
 }

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

@@ -17,27 +17,43 @@ namespace Volo.CmsKit.Admin.Blogs.ClientProxies
     {
         public virtual async Task<BlogDto> GetAsync(Guid id)
         {
-            return await RequestAsync<BlogDto>(nameof(GetAsync), id);
+            return await RequestAsync<BlogDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<PagedResultDto<BlogDto>> GetListAsync(BlogGetListInput input)
         {
-            return await RequestAsync<PagedResultDto<BlogDto>>(nameof(GetListAsync), input);
+            return await RequestAsync<PagedResultDto<BlogDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(BlogGetListInput), input }
+            });
         }
 
         public virtual async Task<BlogDto> CreateAsync(CreateBlogDto input)
         {
-            return await RequestAsync<BlogDto>(nameof(CreateAsync), input);
+            return await RequestAsync<BlogDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(CreateBlogDto), input }
+            });
         }
 
         public virtual async Task<BlogDto> UpdateAsync(Guid id, UpdateBlogDto input)
         {
-            return await RequestAsync<BlogDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<BlogDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(UpdateBlogDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -19,12 +19,19 @@ namespace Volo.CmsKit.Admin.Blogs.ClientProxies
     {
         public virtual async Task<List<BlogFeatureDto>> GetListAsync(Guid blogId)
         {
-            return await RequestAsync<List<BlogFeatureDto>>(nameof(GetListAsync), blogId);
+            return await RequestAsync<List<BlogFeatureDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), blogId }
+            });
         }
 
         public virtual async Task SetAsync(Guid blogId, BlogFeatureInputDto dto)
         {
-            await RequestAsync(nameof(SetAsync), blogId, dto);
+            await RequestAsync(nameof(SetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), blogId },
+                { typeof(BlogFeatureInputDto), dto }
+            });
         }
     }
 }

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

@@ -17,27 +17,43 @@ namespace Volo.CmsKit.Admin.Blogs.ClientProxies
     {
         public virtual async Task<BlogPostDto> CreateAsync(CreateBlogPostDto input)
         {
-            return await RequestAsync<BlogPostDto>(nameof(CreateAsync), input);
+            return await RequestAsync<BlogPostDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(CreateBlogPostDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<BlogPostDto> GetAsync(Guid id)
         {
-            return await RequestAsync<BlogPostDto>(nameof(GetAsync), id);
+            return await RequestAsync<BlogPostDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<PagedResultDto<BlogPostListDto>> GetListAsync(BlogPostGetListInput input)
         {
-            return await RequestAsync<PagedResultDto<BlogPostListDto>>(nameof(GetListAsync), input);
+            return await RequestAsync<PagedResultDto<BlogPostListDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(BlogPostGetListInput), input }
+            });
         }
 
         public virtual async Task<BlogPostDto> UpdateAsync(Guid id, UpdateBlogPostDto input)
         {
-            return await RequestAsync<BlogPostDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<BlogPostDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(UpdateBlogPostDto), input }
+            });
         }
     }
 }

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

@@ -17,17 +17,26 @@ namespace Volo.CmsKit.Admin.Comments.ClientProxies
     {
         public virtual async Task<PagedResultDto<CommentWithAuthorDto>> GetListAsync(CommentGetListInput input)
         {
-            return await RequestAsync<PagedResultDto<CommentWithAuthorDto>>(nameof(GetListAsync), input);
+            return await RequestAsync<PagedResultDto<CommentWithAuthorDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(CommentGetListInput), input }
+            });
         }
 
         public virtual async Task<CommentWithAuthorDto> GetAsync(Guid id)
         {
-            return await RequestAsync<CommentWithAuthorDto>(nameof(GetAsync), id);
+            return await RequestAsync<CommentWithAuthorDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -17,17 +17,26 @@ namespace Volo.CmsKit.Admin.Tags.ClientProxies
     {
         public virtual async Task AddTagToEntityAsync(EntityTagCreateDto input)
         {
-            await RequestAsync(nameof(AddTagToEntityAsync), input);
+            await RequestAsync(nameof(AddTagToEntityAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(EntityTagCreateDto), input }
+            });
         }
 
         public virtual async Task RemoveTagFromEntityAsync(EntityTagRemoveDto input)
         {
-            await RequestAsync(nameof(RemoveTagFromEntityAsync), input);
+            await RequestAsync(nameof(RemoveTagFromEntityAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(EntityTagRemoveDto), input }
+            });
         }
 
         public virtual async Task SetEntityTagsAsync(EntityTagSetDto input)
         {
-            await RequestAsync(nameof(SetEntityTagsAsync), input);
+            await RequestAsync(nameof(SetEntityTagsAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(EntityTagSetDto), input }
+            });
         }
     }
 }

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

@@ -17,12 +17,19 @@ namespace Volo.CmsKit.Admin.MediaDescriptors.ClientProxies
     {
         public virtual async Task<MediaDescriptorDto> CreateAsync(string entityType, CreateMediaInputWithStream inputStream)
         {
-            return await RequestAsync<MediaDescriptorDto>(nameof(CreateAsync), entityType, inputStream);
+            return await RequestAsync<MediaDescriptorDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(CreateMediaInputWithStream), inputStream }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -23,32 +23,52 @@ namespace Volo.CmsKit.Admin.Menus.ClientProxies
 
         public virtual async Task<MenuItemDto> GetAsync(Guid id)
         {
-            return await RequestAsync<MenuItemDto>(nameof(GetAsync), id);
+            return await RequestAsync<MenuItemDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<MenuItemDto> CreateAsync(MenuItemCreateInput input)
         {
-            return await RequestAsync<MenuItemDto>(nameof(CreateAsync), input);
+            return await RequestAsync<MenuItemDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(MenuItemCreateInput), input }
+            });
         }
 
         public virtual async Task<MenuItemDto> UpdateAsync(Guid id, MenuItemUpdateInput input)
         {
-            return await RequestAsync<MenuItemDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<MenuItemDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(MenuItemUpdateInput), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task MoveMenuItemAsync(Guid id, MenuItemMoveInput input)
         {
-            await RequestAsync(nameof(MoveMenuItemAsync), id, input);
+            await RequestAsync(nameof(MoveMenuItemAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(MenuItemMoveInput), input }
+            });
         }
 
         public virtual async Task<PagedResultDto<PageLookupDto>> GetPageLookupAsync(PageLookupInputDto input)
         {
-            return await RequestAsync<PagedResultDto<PageLookupDto>>(nameof(GetPageLookupAsync), input);
+            return await RequestAsync<PagedResultDto<PageLookupDto>>(nameof(GetPageLookupAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(PageLookupInputDto), input }
+            });
         }
     }
 }

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

@@ -17,27 +17,43 @@ namespace Volo.CmsKit.Admin.Pages.ClientProxies
     {
         public virtual async Task<PageDto> GetAsync(Guid id)
         {
-            return await RequestAsync<PageDto>(nameof(GetAsync), id);
+            return await RequestAsync<PageDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<PagedResultDto<PageDto>> GetListAsync(GetPagesInputDto input)
         {
-            return await RequestAsync<PagedResultDto<PageDto>>(nameof(GetListAsync), input);
+            return await RequestAsync<PagedResultDto<PageDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetPagesInputDto), input }
+            });
         }
 
         public virtual async Task<PageDto> CreateAsync(CreatePageInputDto input)
         {
-            return await RequestAsync<PageDto>(nameof(CreateAsync), input);
+            return await RequestAsync<PageDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(CreatePageInputDto), input }
+            });
         }
 
         public virtual async Task<PageDto> UpdateAsync(Guid id, UpdatePageInputDto input)
         {
-            return await RequestAsync<PageDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<PageDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(UpdatePageInputDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -19,27 +19,43 @@ namespace Volo.CmsKit.Admin.Tags.ClientProxies
     {
         public virtual async Task<TagDto> CreateAsync(TagCreateDto input)
         {
-            return await RequestAsync<TagDto>(nameof(CreateAsync), input);
+            return await RequestAsync<TagDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(TagCreateDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<TagDto> GetAsync(Guid id)
         {
-            return await RequestAsync<TagDto>(nameof(GetAsync), id);
+            return await RequestAsync<TagDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<PagedResultDto<TagDto>> GetListAsync(TagGetListInput input)
         {
-            return await RequestAsync<PagedResultDto<TagDto>>(nameof(GetListAsync), input);
+            return await RequestAsync<PagedResultDto<TagDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(TagGetListInput), input }
+            });
         }
 
         public virtual async Task<TagDto> UpdateAsync(Guid id, TagUpdateDto input)
         {
-            return await RequestAsync<TagDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<TagDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(TagUpdateDto), input }
+            });
         }
 
         public virtual async Task<List<TagDefinitionDto>> GetTagDefinitionsAsync()

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

@@ -17,7 +17,11 @@ namespace Volo.CmsKit.Blogs.ClientProxies
     {
         public virtual async Task<BlogFeatureDto> GetOrDefaultAsync(Guid blogId, string featureName)
         {
-            return await RequestAsync<BlogFeatureDto>(nameof(GetOrDefaultAsync), blogId, featureName);
+            return await RequestAsync<BlogFeatureDto>(nameof(GetOrDefaultAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), blogId },
+                { typeof(string), featureName }
+            });
         }
     }
 }

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

@@ -18,7 +18,10 @@ namespace Volo.CmsKit.MediaDescriptors.ClientProxies
     {
         public virtual async Task<RemoteStreamContent> DownloadAsync(Guid id)
         {
-            return await RequestAsync<RemoteStreamContent>(nameof(DownloadAsync), id);
+            return await RequestAsync<RemoteStreamContent>(nameof(DownloadAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -17,12 +17,20 @@ namespace Volo.CmsKit.Public.Blogs.ClientProxies
     {
         public virtual async Task<BlogPostPublicDto> GetAsync(string blogSlug, string blogPostSlug)
         {
-            return await RequestAsync<BlogPostPublicDto>(nameof(GetAsync), blogSlug, blogPostSlug);
+            return await RequestAsync<BlogPostPublicDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), blogSlug },
+                { typeof(string), blogPostSlug }
+            });
         }
 
         public virtual async Task<PagedResultDto<BlogPostPublicDto>> GetListAsync(string blogSlug, PagedAndSortedResultRequestDto input)
         {
-            return await RequestAsync<PagedResultDto<BlogPostPublicDto>>(nameof(GetListAsync), blogSlug, input);
+            return await RequestAsync<PagedResultDto<BlogPostPublicDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), blogSlug },
+                { typeof(PagedAndSortedResultRequestDto), input }
+            });
         }
     }
 }

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

@@ -17,22 +17,38 @@ namespace Volo.CmsKit.Public.Comments.ClientProxies
     {
         public virtual async Task<ListResultDto<CommentWithDetailsDto>> GetListAsync(string entityType, string entityId)
         {
-            return await RequestAsync<ListResultDto<CommentWithDetailsDto>>(nameof(GetListAsync), entityType, entityId);
+            return await RequestAsync<ListResultDto<CommentWithDetailsDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(string), entityId }
+            });
         }
 
         public virtual async Task<CommentDto> CreateAsync(string entityType, string entityId, CreateCommentInput input)
         {
-            return await RequestAsync<CommentDto>(nameof(CreateAsync), entityType, entityId, input);
+            return await RequestAsync<CommentDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(string), entityId },
+                { typeof(CreateCommentInput), input }
+            });
         }
 
         public virtual async Task<CommentDto> UpdateAsync(Guid id, UpdateCommentInput input)
         {
-            return await RequestAsync<CommentDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<CommentDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(UpdateCommentInput), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -17,7 +17,10 @@ namespace Volo.CmsKit.Public.Pages.ClientProxies
     {
         public virtual async Task<PageDto> FindBySlugAsync(string slug)
         {
-            return await RequestAsync<PageDto>(nameof(FindBySlugAsync), slug);
+            return await RequestAsync<PageDto>(nameof(FindBySlugAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), slug }
+            });
         }
     }
 }

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

@@ -18,17 +18,30 @@ namespace Volo.CmsKit.Public.Ratings.ClientProxies
     {
         public virtual async Task<RatingDto> CreateAsync(string entityType, string entityId, CreateUpdateRatingInput input)
         {
-            return await RequestAsync<RatingDto>(nameof(CreateAsync), entityType, entityId, input);
+            return await RequestAsync<RatingDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(string), entityId },
+                { typeof(CreateUpdateRatingInput), input }
+            });
         }
 
         public virtual async Task DeleteAsync(string entityType, string entityId)
         {
-            await RequestAsync(nameof(DeleteAsync), entityType, entityId);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(string), entityId }
+            });
         }
 
         public virtual async Task<List<RatingWithStarCountDto>> GetGroupedStarCountsAsync(string entityType, string entityId)
         {
-            return await RequestAsync<List<RatingWithStarCountDto>>(nameof(GetGroupedStarCountsAsync), entityType, entityId);
+            return await RequestAsync<List<RatingWithStarCountDto>>(nameof(GetGroupedStarCountsAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(string), entityId }
+            });
         }
     }
 }

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

@@ -17,17 +17,31 @@ namespace Volo.CmsKit.Public.Reactions.ClientProxies
     {
         public virtual async Task<ListResultDto<ReactionWithSelectionDto>> GetForSelectionAsync(string entityType, string entityId)
         {
-            return await RequestAsync<ListResultDto<ReactionWithSelectionDto>>(nameof(GetForSelectionAsync), entityType, entityId);
+            return await RequestAsync<ListResultDto<ReactionWithSelectionDto>>(nameof(GetForSelectionAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(string), entityId }
+            });
         }
 
         public virtual async Task CreateAsync(string entityType, string entityId, string reaction)
         {
-            await RequestAsync(nameof(CreateAsync), entityType, entityId, reaction);
+            await RequestAsync(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(string), entityId },
+                { typeof(string), reaction }
+            });
         }
 
         public virtual async Task DeleteAsync(string entityType, string entityId, string reaction)
         {
-            await RequestAsync(nameof(DeleteAsync), entityType, entityId, reaction);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(string), entityId },
+                { typeof(string), reaction }
+            });
         }
     }
 }

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

@@ -18,7 +18,11 @@ namespace Volo.CmsKit.Public.Tags.ClientProxies
     {
         public virtual async Task<List<TagDto>> GetAllRelatedTagsAsync(string entityType, string entityId)
         {
-            return await RequestAsync<List<TagDto>>(nameof(GetAllRelatedTagsAsync), entityType, entityId);
+            return await RequestAsync<List<TagDto>>(nameof(GetAllRelatedTagsAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), entityType },
+                { typeof(string), entityId }
+            });
         }
     }
 }

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

@@ -17,32 +17,50 @@ namespace Volo.Docs.Admin.ClientProxies
     {
         public virtual async Task ClearCacheAsync(ClearCacheInput input)
         {
-            await RequestAsync(nameof(ClearCacheAsync), input);
+            await RequestAsync(nameof(ClearCacheAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(ClearCacheInput), input }
+            });
         }
 
         public virtual async Task PullAllAsync(PullAllDocumentInput input)
         {
-            await RequestAsync(nameof(PullAllAsync), input);
+            await RequestAsync(nameof(PullAllAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(PullAllDocumentInput), input }
+            });
         }
 
         public virtual async Task PullAsync(PullDocumentInput input)
         {
-            await RequestAsync(nameof(PullAsync), input);
+            await RequestAsync(nameof(PullAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(PullDocumentInput), input }
+            });
         }
 
         public virtual async Task<PagedResultDto<DocumentDto>> GetAllAsync(GetAllInput input)
         {
-            return await RequestAsync<PagedResultDto<DocumentDto>>(nameof(GetAllAsync), input);
+            return await RequestAsync<PagedResultDto<DocumentDto>>(nameof(GetAllAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetAllInput), input }
+            });
         }
 
         public virtual async Task RemoveFromCacheAsync(Guid documentId)
         {
-            await RequestAsync(nameof(RemoveFromCacheAsync), documentId);
+            await RequestAsync(nameof(RemoveFromCacheAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), documentId }
+            });
         }
 
         public virtual async Task ReindexAsync(Guid documentId)
         {
-            await RequestAsync(nameof(ReindexAsync), documentId);
+            await RequestAsync(nameof(ReindexAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), documentId }
+            });
         }
     }
 }

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

@@ -17,27 +17,43 @@ namespace Volo.Docs.Admin.ClientProxies
     {
         public virtual async Task<PagedResultDto<ProjectDto>> GetListAsync(PagedAndSortedResultRequestDto input)
         {
-            return await RequestAsync<PagedResultDto<ProjectDto>>(nameof(GetListAsync), input);
+            return await RequestAsync<PagedResultDto<ProjectDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(PagedAndSortedResultRequestDto), input }
+            });
         }
 
         public virtual async Task<ProjectDto> GetAsync(Guid id)
         {
-            return await RequestAsync<ProjectDto>(nameof(GetAsync), id);
+            return await RequestAsync<ProjectDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<ProjectDto> CreateAsync(CreateProjectDto input)
         {
-            return await RequestAsync<ProjectDto>(nameof(CreateAsync), input);
+            return await RequestAsync<ProjectDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(CreateProjectDto), input }
+            });
         }
 
         public virtual async Task<ProjectDto> UpdateAsync(Guid id, UpdateProjectDto input)
         {
-            return await RequestAsync<ProjectDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<ProjectDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(UpdateProjectDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task ReindexAllAsync()
@@ -47,7 +63,10 @@ namespace Volo.Docs.Admin.ClientProxies
 
         public virtual async Task ReindexAsync(ReindexInput input)
         {
-            await RequestAsync(nameof(ReindexAsync), input);
+            await RequestAsync(nameof(ReindexAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(ReindexInput), input }
+            });
         }
     }
 }

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

@@ -18,27 +18,42 @@ namespace Volo.Docs.Documents.ClientProxies
     {
         public virtual async Task<DocumentWithDetailsDto> GetAsync(GetDocumentInput input)
         {
-            return await RequestAsync<DocumentWithDetailsDto>(nameof(GetAsync), input);
+            return await RequestAsync<DocumentWithDetailsDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetDocumentInput), input }
+            });
         }
 
         public virtual async Task<DocumentWithDetailsDto> GetDefaultAsync(GetDefaultDocumentInput input)
         {
-            return await RequestAsync<DocumentWithDetailsDto>(nameof(GetDefaultAsync), input);
+            return await RequestAsync<DocumentWithDetailsDto>(nameof(GetDefaultAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetDefaultDocumentInput), input }
+            });
         }
 
         public virtual async Task<NavigationNode> GetNavigationAsync(GetNavigationDocumentInput input)
         {
-            return await RequestAsync<NavigationNode>(nameof(GetNavigationAsync), input);
+            return await RequestAsync<NavigationNode>(nameof(GetNavigationAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetNavigationDocumentInput), input }
+            });
         }
 
         public virtual async Task<DocumentResourceDto> GetResourceAsync(GetDocumentResourceInput input)
         {
-            return await RequestAsync<DocumentResourceDto>(nameof(GetResourceAsync), input);
+            return await RequestAsync<DocumentResourceDto>(nameof(GetResourceAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetDocumentResourceInput), input }
+            });
         }
 
         public virtual async Task<List<DocumentSearchOutput>> SearchAsync(DocumentSearchInput input)
         {
-            return await RequestAsync<List<DocumentSearchOutput>>(nameof(SearchAsync), input);
+            return await RequestAsync<List<DocumentSearchOutput>>(nameof(SearchAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(DocumentSearchInput), input }
+            });
         }
 
         public virtual async Task<bool> FullSearchEnabledAsync()
@@ -48,12 +63,18 @@ namespace Volo.Docs.Documents.ClientProxies
 
         public virtual async Task<List<String>> GetUrlsAsync(string prefix)
         {
-            return await RequestAsync<List<String>>(nameof(GetUrlsAsync), prefix);
+            return await RequestAsync<List<String>>(nameof(GetUrlsAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), prefix }
+            });
         }
 
         public virtual async Task<DocumentParametersDto> GetParametersAsync(GetParametersDocumentInput input)
         {
-            return await RequestAsync<DocumentParametersDto>(nameof(GetParametersAsync), input);
+            return await RequestAsync<DocumentParametersDto>(nameof(GetParametersAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetParametersDocumentInput), input }
+            });
         }
     }
 }

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

@@ -23,22 +23,36 @@ namespace Volo.Docs.Projects.ClientProxies
 
         public virtual async Task<ProjectDto> GetAsync(string shortName)
         {
-            return await RequestAsync<ProjectDto>(nameof(GetAsync), shortName);
+            return await RequestAsync<ProjectDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), shortName }
+            });
         }
 
         public virtual async Task<string> GetDefaultLanguageCodeAsync(string shortName, string version)
         {
-            return await RequestAsync<string>(nameof(GetDefaultLanguageCodeAsync), shortName, version);
+            return await RequestAsync<string>(nameof(GetDefaultLanguageCodeAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), shortName },
+                { typeof(string), version }
+            });
         }
 
         public virtual async Task<ListResultDto<VersionInfoDto>> GetVersionsAsync(string shortName)
         {
-            return await RequestAsync<ListResultDto<VersionInfoDto>>(nameof(GetVersionsAsync), shortName);
+            return await RequestAsync<ListResultDto<VersionInfoDto>>(nameof(GetVersionsAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), shortName }
+            });
         }
 
         public virtual async Task<LanguageConfig> GetLanguageListAsync(string shortName, string version)
         {
-            return await RequestAsync<LanguageConfig>(nameof(GetLanguageListAsync), shortName, version);
+            return await RequestAsync<LanguageConfig>(nameof(GetLanguageListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), shortName },
+                { typeof(string), version }
+            });
         }
     }
 }

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

@@ -17,12 +17,21 @@ namespace Volo.Abp.FeatureManagement.ClientProxies
     {
         public virtual async Task<GetFeatureListResultDto> GetAsync(string providerName, string providerKey)
         {
-            return await RequestAsync<GetFeatureListResultDto>(nameof(GetAsync), providerName, providerKey);
+            return await RequestAsync<GetFeatureListResultDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), providerName },
+                { typeof(string), providerKey }
+            });
         }
 
         public virtual async Task UpdateAsync(string providerName, string providerKey, UpdateFeaturesDto input)
         {
-            await RequestAsync(nameof(UpdateAsync), providerName, providerKey, input);
+            await RequestAsync(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), providerName },
+                { typeof(string), providerKey },
+                { typeof(UpdateFeaturesDto), input }
+            });
         }
     }
 }

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

@@ -22,27 +22,43 @@ namespace Volo.Abp.Identity.ClientProxies
 
         public virtual async Task<PagedResultDto<IdentityRoleDto>> GetListAsync(GetIdentityRolesInput input)
         {
-            return await RequestAsync<PagedResultDto<IdentityRoleDto>>(nameof(GetListAsync), input);
+            return await RequestAsync<PagedResultDto<IdentityRoleDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetIdentityRolesInput), input }
+            });
         }
 
         public virtual async Task<IdentityRoleDto> GetAsync(Guid id)
         {
-            return await RequestAsync<IdentityRoleDto>(nameof(GetAsync), id);
+            return await RequestAsync<IdentityRoleDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<IdentityRoleDto> CreateAsync(IdentityRoleCreateDto input)
         {
-            return await RequestAsync<IdentityRoleDto>(nameof(CreateAsync), input);
+            return await RequestAsync<IdentityRoleDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(IdentityRoleCreateDto), input }
+            });
         }
 
         public virtual async Task<IdentityRoleDto> UpdateAsync(Guid id, IdentityRoleUpdateDto input)
         {
-            return await RequestAsync<IdentityRoleDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<IdentityRoleDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(IdentityRoleUpdateDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }

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

@@ -17,32 +17,51 @@ namespace Volo.Abp.Identity.ClientProxies
     {
         public virtual async Task<IdentityUserDto> GetAsync(Guid id)
         {
-            return await RequestAsync<IdentityUserDto>(nameof(GetAsync), id);
+            return await RequestAsync<IdentityUserDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<PagedResultDto<IdentityUserDto>> GetListAsync(GetIdentityUsersInput input)
         {
-            return await RequestAsync<PagedResultDto<IdentityUserDto>>(nameof(GetListAsync), input);
+            return await RequestAsync<PagedResultDto<IdentityUserDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetIdentityUsersInput), input }
+            });
         }
 
         public virtual async Task<IdentityUserDto> CreateAsync(IdentityUserCreateDto input)
         {
-            return await RequestAsync<IdentityUserDto>(nameof(CreateAsync), input);
+            return await RequestAsync<IdentityUserDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(IdentityUserCreateDto), input }
+            });
         }
 
         public virtual async Task<IdentityUserDto> UpdateAsync(Guid id, IdentityUserUpdateDto input)
         {
-            return await RequestAsync<IdentityUserDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<IdentityUserDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(IdentityUserUpdateDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<ListResultDto<IdentityRoleDto>> GetRolesAsync(Guid id)
         {
-            return await RequestAsync<ListResultDto<IdentityRoleDto>>(nameof(GetRolesAsync), id);
+            return await RequestAsync<ListResultDto<IdentityRoleDto>>(nameof(GetRolesAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<ListResultDto<IdentityRoleDto>> GetAssignableRolesAsync()
@@ -52,17 +71,27 @@ namespace Volo.Abp.Identity.ClientProxies
 
         public virtual async Task UpdateRolesAsync(Guid id, IdentityUserUpdateRolesDto input)
         {
-            await RequestAsync(nameof(UpdateRolesAsync), id, input);
+            await RequestAsync(nameof(UpdateRolesAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(IdentityUserUpdateRolesDto), input }
+            });
         }
 
         public virtual async Task<IdentityUserDto> FindByUsernameAsync(string userName)
         {
-            return await RequestAsync<IdentityUserDto>(nameof(FindByUsernameAsync), userName);
+            return await RequestAsync<IdentityUserDto>(nameof(FindByUsernameAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), userName }
+            });
         }
 
         public virtual async Task<IdentityUserDto> FindByEmailAsync(string email)
         {
-            return await RequestAsync<IdentityUserDto>(nameof(FindByEmailAsync), email);
+            return await RequestAsync<IdentityUserDto>(nameof(FindByEmailAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), email }
+            });
         }
     }
 }

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

@@ -18,22 +18,34 @@ namespace Volo.Abp.Identity.ClientProxies
     {
         public virtual async Task<UserData> FindByIdAsync(Guid id)
         {
-            return await RequestAsync<UserData>(nameof(FindByIdAsync), id);
+            return await RequestAsync<UserData>(nameof(FindByIdAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<UserData> FindByUserNameAsync(string userName)
         {
-            return await RequestAsync<UserData>(nameof(FindByUserNameAsync), userName);
+            return await RequestAsync<UserData>(nameof(FindByUserNameAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), userName }
+            });
         }
 
         public virtual async Task<ListResultDto<UserData>> SearchAsync(UserLookupSearchInputDto input)
         {
-            return await RequestAsync<ListResultDto<UserData>>(nameof(SearchAsync), input);
+            return await RequestAsync<ListResultDto<UserData>>(nameof(SearchAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(UserLookupSearchInputDto), input }
+            });
         }
 
         public virtual async Task<long> GetCountAsync(UserLookupCountInputDto input)
         {
-            return await RequestAsync<long>(nameof(GetCountAsync), input);
+            return await RequestAsync<long>(nameof(GetCountAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(UserLookupCountInputDto), input }
+            });
         }
     }
 }

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

@@ -22,12 +22,18 @@ namespace Volo.Abp.Identity.ClientProxies
 
         public virtual async Task<ProfileDto> UpdateAsync(UpdateProfileDto input)
         {
-            return await RequestAsync<ProfileDto>(nameof(UpdateAsync), input);
+            return await RequestAsync<ProfileDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(UpdateProfileDto), input }
+            });
         }
 
         public virtual async Task ChangePasswordAsync(ChangePasswordInput input)
         {
-            await RequestAsync(nameof(ChangePasswordAsync), input);
+            await RequestAsync(nameof(ChangePasswordAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(ChangePasswordInput), input }
+            });
         }
     }
 }

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

@@ -17,12 +17,21 @@ namespace Volo.Abp.PermissionManagement.ClientProxies
     {
         public virtual async Task<GetPermissionListResultDto> GetAsync(string providerName, string providerKey)
         {
-            return await RequestAsync<GetPermissionListResultDto>(nameof(GetAsync), providerName, providerKey);
+            return await RequestAsync<GetPermissionListResultDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), providerName },
+                { typeof(string), providerKey }
+            });
         }
 
         public virtual async Task UpdateAsync(string providerName, string providerKey, UpdatePermissionsDto input)
         {
-            await RequestAsync(nameof(UpdateAsync), providerName, providerKey, input);
+            await RequestAsync(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(string), providerName },
+                { typeof(string), providerKey },
+                { typeof(UpdatePermissionsDto), input }
+            });
         }
     }
 }

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

@@ -22,7 +22,10 @@ namespace Volo.Abp.SettingManagement.ClientProxies
 
         public virtual async Task UpdateAsync(UpdateEmailSettingsDto input)
         {
-            await RequestAsync(nameof(UpdateAsync), input);
+            await RequestAsync(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(UpdateEmailSettingsDto), input }
+            });
         }
     }
 }

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

@@ -17,42 +17,68 @@ namespace Volo.Abp.TenantManagement.ClientProxies
     {
         public virtual async Task<TenantDto> GetAsync(Guid id)
         {
-            return await RequestAsync<TenantDto>(nameof(GetAsync), id);
+            return await RequestAsync<TenantDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<PagedResultDto<TenantDto>> GetListAsync(GetTenantsInput input)
         {
-            return await RequestAsync<PagedResultDto<TenantDto>>(nameof(GetListAsync), input);
+            return await RequestAsync<PagedResultDto<TenantDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(GetTenantsInput), input }
+            });
         }
 
         public virtual async Task<TenantDto> CreateAsync(TenantCreateDto input)
         {
-            return await RequestAsync<TenantDto>(nameof(CreateAsync), input);
+            return await RequestAsync<TenantDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(TenantCreateDto), input }
+            });
         }
 
         public virtual async Task<TenantDto> UpdateAsync(Guid id, TenantUpdateDto input)
         {
-            return await RequestAsync<TenantDto>(nameof(UpdateAsync), id, input);
+            return await RequestAsync<TenantDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(TenantUpdateDto), input }
+            });
         }
 
         public virtual async Task DeleteAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteAsync), id);
+            await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task<string> GetDefaultConnectionStringAsync(Guid id)
         {
-            return await RequestAsync<string>(nameof(GetDefaultConnectionStringAsync), id);
+            return await RequestAsync<string>(nameof(GetDefaultConnectionStringAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
 
         public virtual async Task UpdateDefaultConnectionStringAsync(Guid id, string defaultConnectionString)
         {
-            await RequestAsync(nameof(UpdateDefaultConnectionStringAsync), id, defaultConnectionString);
+            await RequestAsync(nameof(UpdateDefaultConnectionStringAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id },
+                { typeof(string), defaultConnectionString }
+            });
         }
 
         public virtual async Task DeleteDefaultConnectionStringAsync(Guid id)
         {
-            await RequestAsync(nameof(DeleteDefaultConnectionStringAsync), id);
+            await RequestAsync(nameof(DeleteDefaultConnectionStringAsync), new ClientProxyRequestTypeValue
+            {
+                { typeof(Guid), id }
+            });
         }
     }
 }