diff --git a/CHANGELOG b/CHANGELOG
index 662db8177..394ee47bc 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,3 +1,6 @@
+2019-08-06 Version 1.36.77
+- Supported GetMediaMeta for IMM.
+
 2019-08-05 Version 1.36.76
 - GetOrderDetail add originalConfig param.
 
diff --git a/VERSION b/VERSION
index 68b105d38..011572096 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.36.76
\ No newline at end of file
+1.36.77
\ No newline at end of file
diff --git a/imm/include/alibabacloud/imm/ImmClient.h b/imm/include/alibabacloud/imm/ImmClient.h
index c88f476ea..d0277dfcf 100644
--- a/imm/include/alibabacloud/imm/ImmClient.h
+++ b/imm/include/alibabacloud/imm/ImmClient.h
@@ -22,74 +22,34 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "ImmExport.h"
-#include "model/ListPornBatchDetectJobsRequest.h"
-#include "model/ListPornBatchDetectJobsResult.h"
 #include "model/DetectImageFacesRequest.h"
 #include "model/DetectImageFacesResult.h"
-#include "model/DetectImageTagsRequest.h"
-#include "model/DetectImageTagsResult.h"
+#include "model/ListPornBatchDetectJobsRequest.h"
+#include "model/ListPornBatchDetectJobsResult.h"
 #include "model/DeleteImageRequest.h"
 #include "model/DeleteImageResult.h"
-#include "model/CreateTagJobRequest.h"
-#include "model/CreateTagJobResult.h"
 #include "model/IndexTagRequest.h"
 #include "model/IndexTagResult.h"
-#include "model/ListProjectsRequest.h"
-#include "model/ListProjectsResult.h"
-#include "model/DeleteSetRequest.h"
-#include "model/DeleteSetResult.h"
-#include "model/GetFaceSearchImageRequest.h"
-#include "model/GetFaceSearchImageResult.h"
+#include "model/CreateTagJobRequest.h"
+#include "model/CreateTagJobResult.h"
 #include "model/CreateVideoAnalyseTaskRequest.h"
 #include "model/CreateVideoAnalyseTaskResult.h"
 #include "model/CompareFaceRequest.h"
 #include "model/CompareFaceResult.h"
-#include "model/DetectTagRequest.h"
-#include "model/DetectTagResult.h"
 #include "model/ListFaceSearchGroupUsersRequest.h"
 #include "model/ListFaceSearchGroupUsersResult.h"
 #include "model/ListFaceSearchGroupImagesRequest.h"
 #include "model/ListFaceSearchGroupImagesResult.h"
-#include "model/CreateCADConversionTaskRequest.h"
-#include "model/CreateCADConversionTaskResult.h"
-#include "model/GetTagJobRequest.h"
-#include "model/GetTagJobResult.h"
-#include "model/DeleteFaceJobRequest.h"
-#include "model/DeleteFaceJobResult.h"
-#include "model/CreateDocIndexTaskRequest.h"
-#include "model/CreateDocIndexTaskResult.h"
 #include "model/PutProjectRequest.h"
 #include "model/PutProjectResult.h"
-#include "model/GetSetRequest.h"
-#include "model/GetSetResult.h"
-#include "model/GetVideoTaskRequest.h"
-#include "model/GetVideoTaskResult.h"
 #include "model/ListSetsRequest.h"
 #include "model/ListSetsResult.h"
-#include "model/SearchDocIndexRequest.h"
-#include "model/SearchDocIndexResult.h"
-#include "model/ListPhotoProcessTasksRequest.h"
-#include "model/ListPhotoProcessTasksResult.h"
-#include "model/ListVideosRequest.h"
-#include "model/ListVideosResult.h"
-#include "model/CreatePornBatchDetectJobRequest.h"
-#include "model/CreatePornBatchDetectJobResult.h"
 #include "model/FindImagesRequest.h"
 #include "model/FindImagesResult.h"
-#include "model/DeleteTagByNameRequest.h"
-#include "model/DeleteTagByNameResult.h"
 #include "model/DetectImageLogosRequest.h"
 #include "model/DetectImageLogosResult.h"
 #include "model/GetProjectRequest.h"
 #include "model/GetProjectResult.h"
-#include "model/DeletePhotoProcessTaskRequest.h"
-#include "model/DeletePhotoProcessTaskResult.h"
-#include "model/ListSetTagsRequest.h"
-#include "model/ListSetTagsResult.h"
-#include "model/DeleteVideoTaskRequest.h"
-#include "model/DeleteVideoTaskResult.h"
-#include "model/FindImagesByTagNamesRequest.h"
-#include "model/FindImagesByTagNamesResult.h"
 #include "model/DeleteTagSetRequest.h"
 #include "model/DeleteTagSetResult.h"
 #include "model/DeleteProjectRequest.h"
@@ -98,106 +58,156 @@
 #include "model/UpdateDocIndexMetaResult.h"
 #include "model/SearchFaceRequest.h"
 #include "model/SearchFaceResult.h"
-#include "model/GetImageRequest.h"
-#include "model/GetImageResult.h"
 #include "model/DetectImageCelebrityRequest.h"
 #include "model/DetectImageCelebrityResult.h"
-#include "model/CreateSetRequest.h"
-#include "model/CreateSetResult.h"
-#include "model/DeletePornBatchDetectJobRequest.h"
-#include "model/DeletePornBatchDetectJobResult.h"
 #include "model/ListFaceSearchGroupsRequest.h"
 #include "model/ListFaceSearchGroupsResult.h"
 #include "model/GetTagSetRequest.h"
 #include "model/GetTagSetResult.h"
-#include "model/ConvertOfficeFormatRequest.h"
-#include "model/ConvertOfficeFormatResult.h"
-#include "model/UpdateFaceGroupRequest.h"
-#include "model/UpdateFaceGroupResult.h"
+#include "model/DeletePornBatchDetectJobRequest.h"
+#include "model/DeletePornBatchDetectJobResult.h"
 #include "model/ListTagPhotosRequest.h"
 #include "model/ListTagPhotosResult.h"
-#include "model/DetectImageBodiesRequest.h"
-#include "model/DetectImageBodiesResult.h"
 #include "model/DeleteFaceSearchImageByIdRequest.h"
 #include "model/DeleteFaceSearchImageByIdResult.h"
 #include "model/IndexVideoRequest.h"
 #include "model/IndexVideoResult.h"
+#include "model/ListVideoAudiosRequest.h"
+#include "model/ListVideoAudiosResult.h"
+#include "model/CreateMergeFaceGroupsJobRequest.h"
+#include "model/CreateMergeFaceGroupsJobResult.h"
+#include "model/ListTagNamesRequest.h"
+#include "model/ListTagNamesResult.h"
+#include "model/CreateOfficeConversionTaskRequest.h"
+#include "model/CreateOfficeConversionTaskResult.h"
+#include "model/GetFaceSearchGroupRequest.h"
+#include "model/GetFaceSearchGroupResult.h"
+#include "model/CompareImageFacesRequest.h"
+#include "model/CompareImageFacesResult.h"
+#include "model/DeleteTagJobRequest.h"
+#include "model/DeleteTagJobResult.h"
+#include "model/PhotoProcessRequest.h"
+#include "model/PhotoProcessResult.h"
+#include "model/DeleteFaceSearchUserRequest.h"
+#include "model/DeleteFaceSearchUserResult.h"
+#include "model/GetOfficeConversionTaskRequest.h"
+#include "model/GetOfficeConversionTaskResult.h"
+#include "model/RegistFaceRequest.h"
+#include "model/RegistFaceResult.h"
+#include "model/CreateTagSetRequest.h"
+#include "model/CreateTagSetResult.h"
+#include "model/GetFaceSearchUserRequest.h"
+#include "model/GetFaceSearchUserResult.h"
+#include "model/CreateFaceSetRequest.h"
+#include "model/CreateFaceSetResult.h"
+#include "model/ListProjectAPIsRequest.h"
+#include "model/ListProjectAPIsResult.h"
+#include "model/DetectImageTextsRequest.h"
+#include "model/DetectImageTextsResult.h"
+#include "model/CreateGroupFacesJobRequest.h"
+#include "model/CreateGroupFacesJobResult.h"
+#include "model/DeleteVideoRequest.h"
+#include "model/DeleteVideoResult.h"
+#include "model/ListOfficeConversionTaskRequest.h"
+#include "model/ListOfficeConversionTaskResult.h"
+#include "model/ListFaceGroupsRequest.h"
+#include "model/ListFaceGroupsResult.h"
+#include "model/DetectImageTagsRequest.h"
+#include "model/DetectImageTagsResult.h"
+#include "model/ListProjectsRequest.h"
+#include "model/ListProjectsResult.h"
+#include "model/DeleteSetRequest.h"
+#include "model/DeleteSetResult.h"
+#include "model/GetFaceSearchImageRequest.h"
+#include "model/GetFaceSearchImageResult.h"
+#include "model/DetectTagRequest.h"
+#include "model/DetectTagResult.h"
+#include "model/CreateCADConversionTaskRequest.h"
+#include "model/CreateCADConversionTaskResult.h"
+#include "model/GetTagJobRequest.h"
+#include "model/GetTagJobResult.h"
+#include "model/DeleteFaceJobRequest.h"
+#include "model/DeleteFaceJobResult.h"
+#include "model/CreateDocIndexTaskRequest.h"
+#include "model/CreateDocIndexTaskResult.h"
+#include "model/GetVideoTaskRequest.h"
+#include "model/GetVideoTaskResult.h"
+#include "model/GetSetRequest.h"
+#include "model/GetSetResult.h"
+#include "model/SearchDocIndexRequest.h"
+#include "model/SearchDocIndexResult.h"
+#include "model/ListPhotoProcessTasksRequest.h"
+#include "model/ListPhotoProcessTasksResult.h"
+#include "model/ListVideosRequest.h"
+#include "model/ListVideosResult.h"
+#include "model/CreatePornBatchDetectJobRequest.h"
+#include "model/CreatePornBatchDetectJobResult.h"
+#include "model/DeleteTagByNameRequest.h"
+#include "model/DeleteTagByNameResult.h"
+#include "model/DeletePhotoProcessTaskRequest.h"
+#include "model/DeletePhotoProcessTaskResult.h"
+#include "model/ListSetTagsRequest.h"
+#include "model/ListSetTagsResult.h"
+#include "model/DeleteVideoTaskRequest.h"
+#include "model/DeleteVideoTaskResult.h"
+#include "model/FindImagesByTagNamesRequest.h"
+#include "model/FindImagesByTagNamesResult.h"
+#include "model/GetImageRequest.h"
+#include "model/GetImageResult.h"
+#include "model/GetMediaMetaRequest.h"
+#include "model/GetMediaMetaResult.h"
+#include "model/CreateSetRequest.h"
+#include "model/CreateSetResult.h"
+#include "model/ConvertOfficeFormatRequest.h"
+#include "model/ConvertOfficeFormatResult.h"
+#include "model/UpdateFaceGroupRequest.h"
+#include "model/UpdateFaceGroupResult.h"
+#include "model/DetectImageBodiesRequest.h"
+#include "model/DetectImageBodiesResult.h"
 #include "model/DeleteDocIndexRequest.h"
 #include "model/DeleteDocIndexResult.h"
 #include "model/GetDocIndexTaskRequest.h"
 #include "model/GetDocIndexTaskResult.h"
 #include "model/GetImageJobRequest.h"
 #include "model/GetImageJobResult.h"
-#include "model/ListVideoAudiosRequest.h"
-#include "model/ListVideoAudiosResult.h"
-#include "model/CreateMergeFaceGroupsJobRequest.h"
-#include "model/CreateMergeFaceGroupsJobResult.h"
 #include "model/DeleteTagByUrlRequest.h"
 #include "model/DeleteTagByUrlResult.h"
 #include "model/ListTagSetsRequest.h"
 #include "model/ListTagSetsResult.h"
-#include "model/ListTagNamesRequest.h"
-#include "model/ListTagNamesResult.h"
-#include "model/CreateOfficeConversionTaskRequest.h"
-#include "model/CreateOfficeConversionTaskResult.h"
 #include "model/DetectQRCodesRequest.h"
 #include "model/DetectQRCodesResult.h"
-#include "model/GetFaceSearchGroupRequest.h"
-#include "model/GetFaceSearchGroupResult.h"
 #include "model/GetVideoRequest.h"
 #include "model/GetVideoResult.h"
 #include "model/ListImagesRequest.h"
 #include "model/ListImagesResult.h"
-#include "model/CompareImageFacesRequest.h"
-#include "model/CompareImageFacesResult.h"
-#include "model/DeleteTagJobRequest.h"
-#include "model/DeleteTagJobResult.h"
 #include "model/DeleteOfficeConversionTaskRequest.h"
 #include "model/DeleteOfficeConversionTaskResult.h"
-#include "model/PhotoProcessRequest.h"
-#include "model/PhotoProcessResult.h"
 #include "model/GetPhotoProcessTaskRequest.h"
 #include "model/GetPhotoProcessTaskResult.h"
 #include "model/ListVideoFramesRequest.h"
 #include "model/ListVideoFramesResult.h"
 #include "model/GetPornBatchDetectJobRequest.h"
 #include "model/GetPornBatchDetectJobResult.h"
-#include "model/DetectLogoRequest.h"
-#include "model/DetectLogoResult.h"
-#include "model/DetectClothesRequest.h"
-#include "model/DetectClothesResult.h"
 #include "model/ListTagJobsRequest.h"
 #include "model/ListTagJobsResult.h"
+#include "model/DetectClothesRequest.h"
+#include "model/DetectClothesResult.h"
+#include "model/DetectLogoRequest.h"
+#include "model/DetectLogoResult.h"
 #include "model/DescribeRegionsRequest.h"
 #include "model/DescribeRegionsResult.h"
-#include "model/DeleteFaceSearchUserRequest.h"
-#include "model/DeleteFaceSearchUserResult.h"
-#include "model/GetOfficeConversionTaskRequest.h"
-#include "model/GetOfficeConversionTaskResult.h"
-#include "model/CreateTagSetRequest.h"
-#include "model/CreateTagSetResult.h"
-#include "model/RegistFaceRequest.h"
-#include "model/RegistFaceResult.h"
 #include "model/FindSimilarFacesRequest.h"
 #include "model/FindSimilarFacesResult.h"
-#include "model/GetFaceSearchUserRequest.h"
-#include "model/GetFaceSearchUserResult.h"
 #include "model/DeleteImageJobRequest.h"
 #include "model/DeleteImageJobResult.h"
-#include "model/CreateFaceSetRequest.h"
-#include "model/CreateFaceSetResult.h"
 #include "model/DeleteFaceSearchGroupRequest.h"
 #include "model/DeleteFaceSearchGroupResult.h"
 #include "model/GetDocIndexRequest.h"
 #include "model/GetDocIndexResult.h"
 #include "model/IndexImageRequest.h"
 #include "model/IndexImageResult.h"
-#include "model/DetectImageTextsRequest.h"
-#include "model/DetectImageTextsResult.h"
 #include "model/ListImageJobsRequest.h"
 #include "model/ListImageJobsResult.h"
-#include "model/CreateGroupFacesJobRequest.h"
-#include "model/CreateGroupFacesJobResult.h"
 #include "model/UpdateImageRequest.h"
 #include "model/UpdateImageResult.h"
 #include "model/ListVideoTasksRequest.h"
@@ -206,14 +216,8 @@
 #include "model/CreateVideoCompressTaskResult.h"
 #include "model/UpdateProjectRequest.h"
 #include "model/UpdateProjectResult.h"
-#include "model/DeleteVideoRequest.h"
-#include "model/DeleteVideoResult.h"
-#include "model/ListOfficeConversionTaskRequest.h"
-#include "model/ListOfficeConversionTaskResult.h"
 #include "model/UpdateSetRequest.h"
 #include "model/UpdateSetResult.h"
-#include "model/ListFaceGroupsRequest.h"
-#include "model/ListFaceGroupsResult.h"
 
 
 namespace AlibabaCloud
@@ -223,108 +227,48 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_IMM_EXPORT ImmClient : public RpcServiceClient
 		{
 		public:
-			typedef Outcome<Error, Model::ListPornBatchDetectJobsResult> ListPornBatchDetectJobsOutcome;
-			typedef std::future<ListPornBatchDetectJobsOutcome> ListPornBatchDetectJobsOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ListPornBatchDetectJobsRequest&, const ListPornBatchDetectJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPornBatchDetectJobsAsyncHandler;
 			typedef Outcome<Error, Model::DetectImageFacesResult> DetectImageFacesOutcome;
 			typedef std::future<DetectImageFacesOutcome> DetectImageFacesOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DetectImageFacesRequest&, const DetectImageFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectImageFacesAsyncHandler;
-			typedef Outcome<Error, Model::DetectImageTagsResult> DetectImageTagsOutcome;
-			typedef std::future<DetectImageTagsOutcome> DetectImageTagsOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DetectImageTagsRequest&, const DetectImageTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectImageTagsAsyncHandler;
+			typedef Outcome<Error, Model::ListPornBatchDetectJobsResult> ListPornBatchDetectJobsOutcome;
+			typedef std::future<ListPornBatchDetectJobsOutcome> ListPornBatchDetectJobsOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListPornBatchDetectJobsRequest&, const ListPornBatchDetectJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPornBatchDetectJobsAsyncHandler;
 			typedef Outcome<Error, Model::DeleteImageResult> DeleteImageOutcome;
 			typedef std::future<DeleteImageOutcome> DeleteImageOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DeleteImageRequest&, const DeleteImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteImageAsyncHandler;
-			typedef Outcome<Error, Model::CreateTagJobResult> CreateTagJobOutcome;
-			typedef std::future<CreateTagJobOutcome> CreateTagJobOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreateTagJobRequest&, const CreateTagJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTagJobAsyncHandler;
 			typedef Outcome<Error, Model::IndexTagResult> IndexTagOutcome;
 			typedef std::future<IndexTagOutcome> IndexTagOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::IndexTagRequest&, const IndexTagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> IndexTagAsyncHandler;
-			typedef Outcome<Error, Model::ListProjectsResult> ListProjectsOutcome;
-			typedef std::future<ListProjectsOutcome> ListProjectsOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ListProjectsRequest&, const ListProjectsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListProjectsAsyncHandler;
-			typedef Outcome<Error, Model::DeleteSetResult> DeleteSetOutcome;
-			typedef std::future<DeleteSetOutcome> DeleteSetOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DeleteSetRequest&, const DeleteSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSetAsyncHandler;
-			typedef Outcome<Error, Model::GetFaceSearchImageResult> GetFaceSearchImageOutcome;
-			typedef std::future<GetFaceSearchImageOutcome> GetFaceSearchImageOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::GetFaceSearchImageRequest&, const GetFaceSearchImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceSearchImageAsyncHandler;
+			typedef Outcome<Error, Model::CreateTagJobResult> CreateTagJobOutcome;
+			typedef std::future<CreateTagJobOutcome> CreateTagJobOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreateTagJobRequest&, const CreateTagJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTagJobAsyncHandler;
 			typedef Outcome<Error, Model::CreateVideoAnalyseTaskResult> CreateVideoAnalyseTaskOutcome;
 			typedef std::future<CreateVideoAnalyseTaskOutcome> CreateVideoAnalyseTaskOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::CreateVideoAnalyseTaskRequest&, const CreateVideoAnalyseTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVideoAnalyseTaskAsyncHandler;
 			typedef Outcome<Error, Model::CompareFaceResult> CompareFaceOutcome;
 			typedef std::future<CompareFaceOutcome> CompareFaceOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::CompareFaceRequest&, const CompareFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompareFaceAsyncHandler;
-			typedef Outcome<Error, Model::DetectTagResult> DetectTagOutcome;
-			typedef std::future<DetectTagOutcome> DetectTagOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DetectTagRequest&, const DetectTagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectTagAsyncHandler;
 			typedef Outcome<Error, Model::ListFaceSearchGroupUsersResult> ListFaceSearchGroupUsersOutcome;
 			typedef std::future<ListFaceSearchGroupUsersOutcome> ListFaceSearchGroupUsersOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::ListFaceSearchGroupUsersRequest&, const ListFaceSearchGroupUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceSearchGroupUsersAsyncHandler;
 			typedef Outcome<Error, Model::ListFaceSearchGroupImagesResult> ListFaceSearchGroupImagesOutcome;
 			typedef std::future<ListFaceSearchGroupImagesOutcome> ListFaceSearchGroupImagesOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::ListFaceSearchGroupImagesRequest&, const ListFaceSearchGroupImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceSearchGroupImagesAsyncHandler;
-			typedef Outcome<Error, Model::CreateCADConversionTaskResult> CreateCADConversionTaskOutcome;
-			typedef std::future<CreateCADConversionTaskOutcome> CreateCADConversionTaskOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreateCADConversionTaskRequest&, const CreateCADConversionTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCADConversionTaskAsyncHandler;
-			typedef Outcome<Error, Model::GetTagJobResult> GetTagJobOutcome;
-			typedef std::future<GetTagJobOutcome> GetTagJobOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::GetTagJobRequest&, const GetTagJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTagJobAsyncHandler;
-			typedef Outcome<Error, Model::DeleteFaceJobResult> DeleteFaceJobOutcome;
-			typedef std::future<DeleteFaceJobOutcome> DeleteFaceJobOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DeleteFaceJobRequest&, const DeleteFaceJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceJobAsyncHandler;
-			typedef Outcome<Error, Model::CreateDocIndexTaskResult> CreateDocIndexTaskOutcome;
-			typedef std::future<CreateDocIndexTaskOutcome> CreateDocIndexTaskOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreateDocIndexTaskRequest&, const CreateDocIndexTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDocIndexTaskAsyncHandler;
 			typedef Outcome<Error, Model::PutProjectResult> PutProjectOutcome;
 			typedef std::future<PutProjectOutcome> PutProjectOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::PutProjectRequest&, const PutProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PutProjectAsyncHandler;
-			typedef Outcome<Error, Model::GetSetResult> GetSetOutcome;
-			typedef std::future<GetSetOutcome> GetSetOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::GetSetRequest&, const GetSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSetAsyncHandler;
-			typedef Outcome<Error, Model::GetVideoTaskResult> GetVideoTaskOutcome;
-			typedef std::future<GetVideoTaskOutcome> GetVideoTaskOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::GetVideoTaskRequest&, const GetVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVideoTaskAsyncHandler;
 			typedef Outcome<Error, Model::ListSetsResult> ListSetsOutcome;
 			typedef std::future<ListSetsOutcome> ListSetsOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::ListSetsRequest&, const ListSetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSetsAsyncHandler;
-			typedef Outcome<Error, Model::SearchDocIndexResult> SearchDocIndexOutcome;
-			typedef std::future<SearchDocIndexOutcome> SearchDocIndexOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::SearchDocIndexRequest&, const SearchDocIndexOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchDocIndexAsyncHandler;
-			typedef Outcome<Error, Model::ListPhotoProcessTasksResult> ListPhotoProcessTasksOutcome;
-			typedef std::future<ListPhotoProcessTasksOutcome> ListPhotoProcessTasksOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ListPhotoProcessTasksRequest&, const ListPhotoProcessTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPhotoProcessTasksAsyncHandler;
-			typedef Outcome<Error, Model::ListVideosResult> ListVideosOutcome;
-			typedef std::future<ListVideosOutcome> ListVideosOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ListVideosRequest&, const ListVideosOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVideosAsyncHandler;
-			typedef Outcome<Error, Model::CreatePornBatchDetectJobResult> CreatePornBatchDetectJobOutcome;
-			typedef std::future<CreatePornBatchDetectJobOutcome> CreatePornBatchDetectJobOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreatePornBatchDetectJobRequest&, const CreatePornBatchDetectJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePornBatchDetectJobAsyncHandler;
 			typedef Outcome<Error, Model::FindImagesResult> FindImagesOutcome;
 			typedef std::future<FindImagesOutcome> FindImagesOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::FindImagesRequest&, const FindImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FindImagesAsyncHandler;
-			typedef Outcome<Error, Model::DeleteTagByNameResult> DeleteTagByNameOutcome;
-			typedef std::future<DeleteTagByNameOutcome> DeleteTagByNameOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DeleteTagByNameRequest&, const DeleteTagByNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTagByNameAsyncHandler;
 			typedef Outcome<Error, Model::DetectImageLogosResult> DetectImageLogosOutcome;
 			typedef std::future<DetectImageLogosOutcome> DetectImageLogosOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DetectImageLogosRequest&, const DetectImageLogosOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectImageLogosAsyncHandler;
 			typedef Outcome<Error, Model::GetProjectResult> GetProjectOutcome;
 			typedef std::future<GetProjectOutcome> GetProjectOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::GetProjectRequest&, const GetProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetProjectAsyncHandler;
-			typedef Outcome<Error, Model::DeletePhotoProcessTaskResult> DeletePhotoProcessTaskOutcome;
-			typedef std::future<DeletePhotoProcessTaskOutcome> DeletePhotoProcessTaskOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DeletePhotoProcessTaskRequest&, const DeletePhotoProcessTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePhotoProcessTaskAsyncHandler;
-			typedef Outcome<Error, Model::ListSetTagsResult> ListSetTagsOutcome;
-			typedef std::future<ListSetTagsOutcome> ListSetTagsOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ListSetTagsRequest&, const ListSetTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSetTagsAsyncHandler;
-			typedef Outcome<Error, Model::DeleteVideoTaskResult> DeleteVideoTaskOutcome;
-			typedef std::future<DeleteVideoTaskOutcome> DeleteVideoTaskOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DeleteVideoTaskRequest&, const DeleteVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVideoTaskAsyncHandler;
-			typedef Outcome<Error, Model::FindImagesByTagNamesResult> FindImagesByTagNamesOutcome;
-			typedef std::future<FindImagesByTagNamesOutcome> FindImagesByTagNamesOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::FindImagesByTagNamesRequest&, const FindImagesByTagNamesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FindImagesByTagNamesAsyncHandler;
 			typedef Outcome<Error, Model::DeleteTagSetResult> DeleteTagSetOutcome;
 			typedef std::future<DeleteTagSetOutcome> DeleteTagSetOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DeleteTagSetRequest&, const DeleteTagSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTagSetAsyncHandler;
@@ -337,42 +281,165 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SearchFaceResult> SearchFaceOutcome;
 			typedef std::future<SearchFaceOutcome> SearchFaceOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::SearchFaceRequest&, const SearchFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchFaceAsyncHandler;
-			typedef Outcome<Error, Model::GetImageResult> GetImageOutcome;
-			typedef std::future<GetImageOutcome> GetImageOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::GetImageRequest&, const GetImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetImageAsyncHandler;
 			typedef Outcome<Error, Model::DetectImageCelebrityResult> DetectImageCelebrityOutcome;
 			typedef std::future<DetectImageCelebrityOutcome> DetectImageCelebrityOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DetectImageCelebrityRequest&, const DetectImageCelebrityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectImageCelebrityAsyncHandler;
-			typedef Outcome<Error, Model::CreateSetResult> CreateSetOutcome;
-			typedef std::future<CreateSetOutcome> CreateSetOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreateSetRequest&, const CreateSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSetAsyncHandler;
-			typedef Outcome<Error, Model::DeletePornBatchDetectJobResult> DeletePornBatchDetectJobOutcome;
-			typedef std::future<DeletePornBatchDetectJobOutcome> DeletePornBatchDetectJobOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DeletePornBatchDetectJobRequest&, const DeletePornBatchDetectJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePornBatchDetectJobAsyncHandler;
 			typedef Outcome<Error, Model::ListFaceSearchGroupsResult> ListFaceSearchGroupsOutcome;
 			typedef std::future<ListFaceSearchGroupsOutcome> ListFaceSearchGroupsOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::ListFaceSearchGroupsRequest&, const ListFaceSearchGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceSearchGroupsAsyncHandler;
 			typedef Outcome<Error, Model::GetTagSetResult> GetTagSetOutcome;
 			typedef std::future<GetTagSetOutcome> GetTagSetOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::GetTagSetRequest&, const GetTagSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTagSetAsyncHandler;
-			typedef Outcome<Error, Model::ConvertOfficeFormatResult> ConvertOfficeFormatOutcome;
-			typedef std::future<ConvertOfficeFormatOutcome> ConvertOfficeFormatOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ConvertOfficeFormatRequest&, const ConvertOfficeFormatOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConvertOfficeFormatAsyncHandler;
-			typedef Outcome<Error, Model::UpdateFaceGroupResult> UpdateFaceGroupOutcome;
-			typedef std::future<UpdateFaceGroupOutcome> UpdateFaceGroupOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::UpdateFaceGroupRequest&, const UpdateFaceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFaceGroupAsyncHandler;
+			typedef Outcome<Error, Model::DeletePornBatchDetectJobResult> DeletePornBatchDetectJobOutcome;
+			typedef std::future<DeletePornBatchDetectJobOutcome> DeletePornBatchDetectJobOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DeletePornBatchDetectJobRequest&, const DeletePornBatchDetectJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePornBatchDetectJobAsyncHandler;
 			typedef Outcome<Error, Model::ListTagPhotosResult> ListTagPhotosOutcome;
 			typedef std::future<ListTagPhotosOutcome> ListTagPhotosOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::ListTagPhotosRequest&, const ListTagPhotosOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagPhotosAsyncHandler;
-			typedef Outcome<Error, Model::DetectImageBodiesResult> DetectImageBodiesOutcome;
-			typedef std::future<DetectImageBodiesOutcome> DetectImageBodiesOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DetectImageBodiesRequest&, const DetectImageBodiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectImageBodiesAsyncHandler;
 			typedef Outcome<Error, Model::DeleteFaceSearchImageByIdResult> DeleteFaceSearchImageByIdOutcome;
 			typedef std::future<DeleteFaceSearchImageByIdOutcome> DeleteFaceSearchImageByIdOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DeleteFaceSearchImageByIdRequest&, const DeleteFaceSearchImageByIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceSearchImageByIdAsyncHandler;
 			typedef Outcome<Error, Model::IndexVideoResult> IndexVideoOutcome;
 			typedef std::future<IndexVideoOutcome> IndexVideoOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::IndexVideoRequest&, const IndexVideoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> IndexVideoAsyncHandler;
+			typedef Outcome<Error, Model::ListVideoAudiosResult> ListVideoAudiosOutcome;
+			typedef std::future<ListVideoAudiosOutcome> ListVideoAudiosOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListVideoAudiosRequest&, const ListVideoAudiosOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVideoAudiosAsyncHandler;
+			typedef Outcome<Error, Model::CreateMergeFaceGroupsJobResult> CreateMergeFaceGroupsJobOutcome;
+			typedef std::future<CreateMergeFaceGroupsJobOutcome> CreateMergeFaceGroupsJobOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreateMergeFaceGroupsJobRequest&, const CreateMergeFaceGroupsJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMergeFaceGroupsJobAsyncHandler;
+			typedef Outcome<Error, Model::ListTagNamesResult> ListTagNamesOutcome;
+			typedef std::future<ListTagNamesOutcome> ListTagNamesOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListTagNamesRequest&, const ListTagNamesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagNamesAsyncHandler;
+			typedef Outcome<Error, Model::CreateOfficeConversionTaskResult> CreateOfficeConversionTaskOutcome;
+			typedef std::future<CreateOfficeConversionTaskOutcome> CreateOfficeConversionTaskOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreateOfficeConversionTaskRequest&, const CreateOfficeConversionTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOfficeConversionTaskAsyncHandler;
+			typedef Outcome<Error, Model::GetFaceSearchGroupResult> GetFaceSearchGroupOutcome;
+			typedef std::future<GetFaceSearchGroupOutcome> GetFaceSearchGroupOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::GetFaceSearchGroupRequest&, const GetFaceSearchGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceSearchGroupAsyncHandler;
+			typedef Outcome<Error, Model::CompareImageFacesResult> CompareImageFacesOutcome;
+			typedef std::future<CompareImageFacesOutcome> CompareImageFacesOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CompareImageFacesRequest&, const CompareImageFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompareImageFacesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteTagJobResult> DeleteTagJobOutcome;
+			typedef std::future<DeleteTagJobOutcome> DeleteTagJobOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DeleteTagJobRequest&, const DeleteTagJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTagJobAsyncHandler;
+			typedef Outcome<Error, Model::PhotoProcessResult> PhotoProcessOutcome;
+			typedef std::future<PhotoProcessOutcome> PhotoProcessOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::PhotoProcessRequest&, const PhotoProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PhotoProcessAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFaceSearchUserResult> DeleteFaceSearchUserOutcome;
+			typedef std::future<DeleteFaceSearchUserOutcome> DeleteFaceSearchUserOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DeleteFaceSearchUserRequest&, const DeleteFaceSearchUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceSearchUserAsyncHandler;
+			typedef Outcome<Error, Model::GetOfficeConversionTaskResult> GetOfficeConversionTaskOutcome;
+			typedef std::future<GetOfficeConversionTaskOutcome> GetOfficeConversionTaskOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::GetOfficeConversionTaskRequest&, const GetOfficeConversionTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetOfficeConversionTaskAsyncHandler;
+			typedef Outcome<Error, Model::RegistFaceResult> RegistFaceOutcome;
+			typedef std::future<RegistFaceOutcome> RegistFaceOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::RegistFaceRequest&, const RegistFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RegistFaceAsyncHandler;
+			typedef Outcome<Error, Model::CreateTagSetResult> CreateTagSetOutcome;
+			typedef std::future<CreateTagSetOutcome> CreateTagSetOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreateTagSetRequest&, const CreateTagSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTagSetAsyncHandler;
+			typedef Outcome<Error, Model::GetFaceSearchUserResult> GetFaceSearchUserOutcome;
+			typedef std::future<GetFaceSearchUserOutcome> GetFaceSearchUserOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::GetFaceSearchUserRequest&, const GetFaceSearchUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceSearchUserAsyncHandler;
+			typedef Outcome<Error, Model::CreateFaceSetResult> CreateFaceSetOutcome;
+			typedef std::future<CreateFaceSetOutcome> CreateFaceSetOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreateFaceSetRequest&, const CreateFaceSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFaceSetAsyncHandler;
+			typedef Outcome<Error, Model::ListProjectAPIsResult> ListProjectAPIsOutcome;
+			typedef std::future<ListProjectAPIsOutcome> ListProjectAPIsOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListProjectAPIsRequest&, const ListProjectAPIsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListProjectAPIsAsyncHandler;
+			typedef Outcome<Error, Model::DetectImageTextsResult> DetectImageTextsOutcome;
+			typedef std::future<DetectImageTextsOutcome> DetectImageTextsOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DetectImageTextsRequest&, const DetectImageTextsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectImageTextsAsyncHandler;
+			typedef Outcome<Error, Model::CreateGroupFacesJobResult> CreateGroupFacesJobOutcome;
+			typedef std::future<CreateGroupFacesJobOutcome> CreateGroupFacesJobOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreateGroupFacesJobRequest&, const CreateGroupFacesJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGroupFacesJobAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVideoResult> DeleteVideoOutcome;
+			typedef std::future<DeleteVideoOutcome> DeleteVideoOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DeleteVideoRequest&, const DeleteVideoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVideoAsyncHandler;
+			typedef Outcome<Error, Model::ListOfficeConversionTaskResult> ListOfficeConversionTaskOutcome;
+			typedef std::future<ListOfficeConversionTaskOutcome> ListOfficeConversionTaskOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListOfficeConversionTaskRequest&, const ListOfficeConversionTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListOfficeConversionTaskAsyncHandler;
+			typedef Outcome<Error, Model::ListFaceGroupsResult> ListFaceGroupsOutcome;
+			typedef std::future<ListFaceGroupsOutcome> ListFaceGroupsOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListFaceGroupsRequest&, const ListFaceGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceGroupsAsyncHandler;
+			typedef Outcome<Error, Model::DetectImageTagsResult> DetectImageTagsOutcome;
+			typedef std::future<DetectImageTagsOutcome> DetectImageTagsOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DetectImageTagsRequest&, const DetectImageTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectImageTagsAsyncHandler;
+			typedef Outcome<Error, Model::ListProjectsResult> ListProjectsOutcome;
+			typedef std::future<ListProjectsOutcome> ListProjectsOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListProjectsRequest&, const ListProjectsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListProjectsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSetResult> DeleteSetOutcome;
+			typedef std::future<DeleteSetOutcome> DeleteSetOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DeleteSetRequest&, const DeleteSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSetAsyncHandler;
+			typedef Outcome<Error, Model::GetFaceSearchImageResult> GetFaceSearchImageOutcome;
+			typedef std::future<GetFaceSearchImageOutcome> GetFaceSearchImageOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::GetFaceSearchImageRequest&, const GetFaceSearchImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceSearchImageAsyncHandler;
+			typedef Outcome<Error, Model::DetectTagResult> DetectTagOutcome;
+			typedef std::future<DetectTagOutcome> DetectTagOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DetectTagRequest&, const DetectTagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectTagAsyncHandler;
+			typedef Outcome<Error, Model::CreateCADConversionTaskResult> CreateCADConversionTaskOutcome;
+			typedef std::future<CreateCADConversionTaskOutcome> CreateCADConversionTaskOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreateCADConversionTaskRequest&, const CreateCADConversionTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCADConversionTaskAsyncHandler;
+			typedef Outcome<Error, Model::GetTagJobResult> GetTagJobOutcome;
+			typedef std::future<GetTagJobOutcome> GetTagJobOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::GetTagJobRequest&, const GetTagJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTagJobAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFaceJobResult> DeleteFaceJobOutcome;
+			typedef std::future<DeleteFaceJobOutcome> DeleteFaceJobOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DeleteFaceJobRequest&, const DeleteFaceJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceJobAsyncHandler;
+			typedef Outcome<Error, Model::CreateDocIndexTaskResult> CreateDocIndexTaskOutcome;
+			typedef std::future<CreateDocIndexTaskOutcome> CreateDocIndexTaskOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreateDocIndexTaskRequest&, const CreateDocIndexTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDocIndexTaskAsyncHandler;
+			typedef Outcome<Error, Model::GetVideoTaskResult> GetVideoTaskOutcome;
+			typedef std::future<GetVideoTaskOutcome> GetVideoTaskOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::GetVideoTaskRequest&, const GetVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVideoTaskAsyncHandler;
+			typedef Outcome<Error, Model::GetSetResult> GetSetOutcome;
+			typedef std::future<GetSetOutcome> GetSetOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::GetSetRequest&, const GetSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSetAsyncHandler;
+			typedef Outcome<Error, Model::SearchDocIndexResult> SearchDocIndexOutcome;
+			typedef std::future<SearchDocIndexOutcome> SearchDocIndexOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::SearchDocIndexRequest&, const SearchDocIndexOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchDocIndexAsyncHandler;
+			typedef Outcome<Error, Model::ListPhotoProcessTasksResult> ListPhotoProcessTasksOutcome;
+			typedef std::future<ListPhotoProcessTasksOutcome> ListPhotoProcessTasksOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListPhotoProcessTasksRequest&, const ListPhotoProcessTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPhotoProcessTasksAsyncHandler;
+			typedef Outcome<Error, Model::ListVideosResult> ListVideosOutcome;
+			typedef std::future<ListVideosOutcome> ListVideosOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListVideosRequest&, const ListVideosOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVideosAsyncHandler;
+			typedef Outcome<Error, Model::CreatePornBatchDetectJobResult> CreatePornBatchDetectJobOutcome;
+			typedef std::future<CreatePornBatchDetectJobOutcome> CreatePornBatchDetectJobOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreatePornBatchDetectJobRequest&, const CreatePornBatchDetectJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePornBatchDetectJobAsyncHandler;
+			typedef Outcome<Error, Model::DeleteTagByNameResult> DeleteTagByNameOutcome;
+			typedef std::future<DeleteTagByNameOutcome> DeleteTagByNameOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DeleteTagByNameRequest&, const DeleteTagByNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTagByNameAsyncHandler;
+			typedef Outcome<Error, Model::DeletePhotoProcessTaskResult> DeletePhotoProcessTaskOutcome;
+			typedef std::future<DeletePhotoProcessTaskOutcome> DeletePhotoProcessTaskOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DeletePhotoProcessTaskRequest&, const DeletePhotoProcessTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePhotoProcessTaskAsyncHandler;
+			typedef Outcome<Error, Model::ListSetTagsResult> ListSetTagsOutcome;
+			typedef std::future<ListSetTagsOutcome> ListSetTagsOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ListSetTagsRequest&, const ListSetTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSetTagsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVideoTaskResult> DeleteVideoTaskOutcome;
+			typedef std::future<DeleteVideoTaskOutcome> DeleteVideoTaskOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DeleteVideoTaskRequest&, const DeleteVideoTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVideoTaskAsyncHandler;
+			typedef Outcome<Error, Model::FindImagesByTagNamesResult> FindImagesByTagNamesOutcome;
+			typedef std::future<FindImagesByTagNamesOutcome> FindImagesByTagNamesOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::FindImagesByTagNamesRequest&, const FindImagesByTagNamesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FindImagesByTagNamesAsyncHandler;
+			typedef Outcome<Error, Model::GetImageResult> GetImageOutcome;
+			typedef std::future<GetImageOutcome> GetImageOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::GetImageRequest&, const GetImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetImageAsyncHandler;
+			typedef Outcome<Error, Model::GetMediaMetaResult> GetMediaMetaOutcome;
+			typedef std::future<GetMediaMetaOutcome> GetMediaMetaOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::GetMediaMetaRequest&, const GetMediaMetaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMediaMetaAsyncHandler;
+			typedef Outcome<Error, Model::CreateSetResult> CreateSetOutcome;
+			typedef std::future<CreateSetOutcome> CreateSetOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::CreateSetRequest&, const CreateSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSetAsyncHandler;
+			typedef Outcome<Error, Model::ConvertOfficeFormatResult> ConvertOfficeFormatOutcome;
+			typedef std::future<ConvertOfficeFormatOutcome> ConvertOfficeFormatOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::ConvertOfficeFormatRequest&, const ConvertOfficeFormatOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConvertOfficeFormatAsyncHandler;
+			typedef Outcome<Error, Model::UpdateFaceGroupResult> UpdateFaceGroupOutcome;
+			typedef std::future<UpdateFaceGroupOutcome> UpdateFaceGroupOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::UpdateFaceGroupRequest&, const UpdateFaceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFaceGroupAsyncHandler;
+			typedef Outcome<Error, Model::DetectImageBodiesResult> DetectImageBodiesOutcome;
+			typedef std::future<DetectImageBodiesOutcome> DetectImageBodiesOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DetectImageBodiesRequest&, const DetectImageBodiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectImageBodiesAsyncHandler;
 			typedef Outcome<Error, Model::DeleteDocIndexResult> DeleteDocIndexOutcome;
 			typedef std::future<DeleteDocIndexOutcome> DeleteDocIndexOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DeleteDocIndexRequest&, const DeleteDocIndexOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDocIndexAsyncHandler;
@@ -382,48 +449,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetImageJobResult> GetImageJobOutcome;
 			typedef std::future<GetImageJobOutcome> GetImageJobOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::GetImageJobRequest&, const GetImageJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetImageJobAsyncHandler;
-			typedef Outcome<Error, Model::ListVideoAudiosResult> ListVideoAudiosOutcome;
-			typedef std::future<ListVideoAudiosOutcome> ListVideoAudiosOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ListVideoAudiosRequest&, const ListVideoAudiosOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVideoAudiosAsyncHandler;
-			typedef Outcome<Error, Model::CreateMergeFaceGroupsJobResult> CreateMergeFaceGroupsJobOutcome;
-			typedef std::future<CreateMergeFaceGroupsJobOutcome> CreateMergeFaceGroupsJobOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreateMergeFaceGroupsJobRequest&, const CreateMergeFaceGroupsJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMergeFaceGroupsJobAsyncHandler;
 			typedef Outcome<Error, Model::DeleteTagByUrlResult> DeleteTagByUrlOutcome;
 			typedef std::future<DeleteTagByUrlOutcome> DeleteTagByUrlOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DeleteTagByUrlRequest&, const DeleteTagByUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTagByUrlAsyncHandler;
 			typedef Outcome<Error, Model::ListTagSetsResult> ListTagSetsOutcome;
 			typedef std::future<ListTagSetsOutcome> ListTagSetsOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::ListTagSetsRequest&, const ListTagSetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagSetsAsyncHandler;
-			typedef Outcome<Error, Model::ListTagNamesResult> ListTagNamesOutcome;
-			typedef std::future<ListTagNamesOutcome> ListTagNamesOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ListTagNamesRequest&, const ListTagNamesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagNamesAsyncHandler;
-			typedef Outcome<Error, Model::CreateOfficeConversionTaskResult> CreateOfficeConversionTaskOutcome;
-			typedef std::future<CreateOfficeConversionTaskOutcome> CreateOfficeConversionTaskOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreateOfficeConversionTaskRequest&, const CreateOfficeConversionTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOfficeConversionTaskAsyncHandler;
 			typedef Outcome<Error, Model::DetectQRCodesResult> DetectQRCodesOutcome;
 			typedef std::future<DetectQRCodesOutcome> DetectQRCodesOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DetectQRCodesRequest&, const DetectQRCodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectQRCodesAsyncHandler;
-			typedef Outcome<Error, Model::GetFaceSearchGroupResult> GetFaceSearchGroupOutcome;
-			typedef std::future<GetFaceSearchGroupOutcome> GetFaceSearchGroupOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::GetFaceSearchGroupRequest&, const GetFaceSearchGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceSearchGroupAsyncHandler;
 			typedef Outcome<Error, Model::GetVideoResult> GetVideoOutcome;
 			typedef std::future<GetVideoOutcome> GetVideoOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::GetVideoRequest&, const GetVideoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVideoAsyncHandler;
 			typedef Outcome<Error, Model::ListImagesResult> ListImagesOutcome;
 			typedef std::future<ListImagesOutcome> ListImagesOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::ListImagesRequest&, const ListImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListImagesAsyncHandler;
-			typedef Outcome<Error, Model::CompareImageFacesResult> CompareImageFacesOutcome;
-			typedef std::future<CompareImageFacesOutcome> CompareImageFacesOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CompareImageFacesRequest&, const CompareImageFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompareImageFacesAsyncHandler;
-			typedef Outcome<Error, Model::DeleteTagJobResult> DeleteTagJobOutcome;
-			typedef std::future<DeleteTagJobOutcome> DeleteTagJobOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DeleteTagJobRequest&, const DeleteTagJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTagJobAsyncHandler;
 			typedef Outcome<Error, Model::DeleteOfficeConversionTaskResult> DeleteOfficeConversionTaskOutcome;
 			typedef std::future<DeleteOfficeConversionTaskOutcome> DeleteOfficeConversionTaskOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DeleteOfficeConversionTaskRequest&, const DeleteOfficeConversionTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteOfficeConversionTaskAsyncHandler;
-			typedef Outcome<Error, Model::PhotoProcessResult> PhotoProcessOutcome;
-			typedef std::future<PhotoProcessOutcome> PhotoProcessOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::PhotoProcessRequest&, const PhotoProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PhotoProcessAsyncHandler;
 			typedef Outcome<Error, Model::GetPhotoProcessTaskResult> GetPhotoProcessTaskOutcome;
 			typedef std::future<GetPhotoProcessTaskOutcome> GetPhotoProcessTaskOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::GetPhotoProcessTaskRequest&, const GetPhotoProcessTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPhotoProcessTaskAsyncHandler;
@@ -433,42 +476,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetPornBatchDetectJobResult> GetPornBatchDetectJobOutcome;
 			typedef std::future<GetPornBatchDetectJobOutcome> GetPornBatchDetectJobOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::GetPornBatchDetectJobRequest&, const GetPornBatchDetectJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPornBatchDetectJobAsyncHandler;
-			typedef Outcome<Error, Model::DetectLogoResult> DetectLogoOutcome;
-			typedef std::future<DetectLogoOutcome> DetectLogoOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DetectLogoRequest&, const DetectLogoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectLogoAsyncHandler;
-			typedef Outcome<Error, Model::DetectClothesResult> DetectClothesOutcome;
-			typedef std::future<DetectClothesOutcome> DetectClothesOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DetectClothesRequest&, const DetectClothesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectClothesAsyncHandler;
 			typedef Outcome<Error, Model::ListTagJobsResult> ListTagJobsOutcome;
 			typedef std::future<ListTagJobsOutcome> ListTagJobsOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::ListTagJobsRequest&, const ListTagJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagJobsAsyncHandler;
+			typedef Outcome<Error, Model::DetectClothesResult> DetectClothesOutcome;
+			typedef std::future<DetectClothesOutcome> DetectClothesOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DetectClothesRequest&, const DetectClothesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectClothesAsyncHandler;
+			typedef Outcome<Error, Model::DetectLogoResult> DetectLogoOutcome;
+			typedef std::future<DetectLogoOutcome> DetectLogoOutcomeCallable;
+			typedef std::function<void(const ImmClient*, const Model::DetectLogoRequest&, const DetectLogoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectLogoAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
 			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
-			typedef Outcome<Error, Model::DeleteFaceSearchUserResult> DeleteFaceSearchUserOutcome;
-			typedef std::future<DeleteFaceSearchUserOutcome> DeleteFaceSearchUserOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DeleteFaceSearchUserRequest&, const DeleteFaceSearchUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceSearchUserAsyncHandler;
-			typedef Outcome<Error, Model::GetOfficeConversionTaskResult> GetOfficeConversionTaskOutcome;
-			typedef std::future<GetOfficeConversionTaskOutcome> GetOfficeConversionTaskOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::GetOfficeConversionTaskRequest&, const GetOfficeConversionTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetOfficeConversionTaskAsyncHandler;
-			typedef Outcome<Error, Model::CreateTagSetResult> CreateTagSetOutcome;
-			typedef std::future<CreateTagSetOutcome> CreateTagSetOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreateTagSetRequest&, const CreateTagSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTagSetAsyncHandler;
-			typedef Outcome<Error, Model::RegistFaceResult> RegistFaceOutcome;
-			typedef std::future<RegistFaceOutcome> RegistFaceOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::RegistFaceRequest&, const RegistFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RegistFaceAsyncHandler;
 			typedef Outcome<Error, Model::FindSimilarFacesResult> FindSimilarFacesOutcome;
 			typedef std::future<FindSimilarFacesOutcome> FindSimilarFacesOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::FindSimilarFacesRequest&, const FindSimilarFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FindSimilarFacesAsyncHandler;
-			typedef Outcome<Error, Model::GetFaceSearchUserResult> GetFaceSearchUserOutcome;
-			typedef std::future<GetFaceSearchUserOutcome> GetFaceSearchUserOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::GetFaceSearchUserRequest&, const GetFaceSearchUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceSearchUserAsyncHandler;
 			typedef Outcome<Error, Model::DeleteImageJobResult> DeleteImageJobOutcome;
 			typedef std::future<DeleteImageJobOutcome> DeleteImageJobOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DeleteImageJobRequest&, const DeleteImageJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteImageJobAsyncHandler;
-			typedef Outcome<Error, Model::CreateFaceSetResult> CreateFaceSetOutcome;
-			typedef std::future<CreateFaceSetOutcome> CreateFaceSetOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreateFaceSetRequest&, const CreateFaceSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFaceSetAsyncHandler;
 			typedef Outcome<Error, Model::DeleteFaceSearchGroupResult> DeleteFaceSearchGroupOutcome;
 			typedef std::future<DeleteFaceSearchGroupOutcome> DeleteFaceSearchGroupOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::DeleteFaceSearchGroupRequest&, const DeleteFaceSearchGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceSearchGroupAsyncHandler;
@@ -478,15 +503,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::IndexImageResult> IndexImageOutcome;
 			typedef std::future<IndexImageOutcome> IndexImageOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::IndexImageRequest&, const IndexImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> IndexImageAsyncHandler;
-			typedef Outcome<Error, Model::DetectImageTextsResult> DetectImageTextsOutcome;
-			typedef std::future<DetectImageTextsOutcome> DetectImageTextsOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DetectImageTextsRequest&, const DetectImageTextsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectImageTextsAsyncHandler;
 			typedef Outcome<Error, Model::ListImageJobsResult> ListImageJobsOutcome;
 			typedef std::future<ListImageJobsOutcome> ListImageJobsOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::ListImageJobsRequest&, const ListImageJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListImageJobsAsyncHandler;
-			typedef Outcome<Error, Model::CreateGroupFacesJobResult> CreateGroupFacesJobOutcome;
-			typedef std::future<CreateGroupFacesJobOutcome> CreateGroupFacesJobOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::CreateGroupFacesJobRequest&, const CreateGroupFacesJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGroupFacesJobAsyncHandler;
 			typedef Outcome<Error, Model::UpdateImageResult> UpdateImageOutcome;
 			typedef std::future<UpdateImageOutcome> UpdateImageOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::UpdateImageRequest&, const UpdateImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateImageAsyncHandler;
@@ -499,125 +518,56 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateProjectResult> UpdateProjectOutcome;
 			typedef std::future<UpdateProjectOutcome> UpdateProjectOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::UpdateProjectRequest&, const UpdateProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateProjectAsyncHandler;
-			typedef Outcome<Error, Model::DeleteVideoResult> DeleteVideoOutcome;
-			typedef std::future<DeleteVideoOutcome> DeleteVideoOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::DeleteVideoRequest&, const DeleteVideoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVideoAsyncHandler;
-			typedef Outcome<Error, Model::ListOfficeConversionTaskResult> ListOfficeConversionTaskOutcome;
-			typedef std::future<ListOfficeConversionTaskOutcome> ListOfficeConversionTaskOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ListOfficeConversionTaskRequest&, const ListOfficeConversionTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListOfficeConversionTaskAsyncHandler;
 			typedef Outcome<Error, Model::UpdateSetResult> UpdateSetOutcome;
 			typedef std::future<UpdateSetOutcome> UpdateSetOutcomeCallable;
 			typedef std::function<void(const ImmClient*, const Model::UpdateSetRequest&, const UpdateSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSetAsyncHandler;
-			typedef Outcome<Error, Model::ListFaceGroupsResult> ListFaceGroupsOutcome;
-			typedef std::future<ListFaceGroupsOutcome> ListFaceGroupsOutcomeCallable;
-			typedef std::function<void(const ImmClient*, const Model::ListFaceGroupsRequest&, const ListFaceGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceGroupsAsyncHandler;
 
 			ImmClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			ImmClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			ImmClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~ImmClient();
-			ListPornBatchDetectJobsOutcome listPornBatchDetectJobs(const Model::ListPornBatchDetectJobsRequest &request)const;
-			void listPornBatchDetectJobsAsync(const Model::ListPornBatchDetectJobsRequest& request, const ListPornBatchDetectJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListPornBatchDetectJobsOutcomeCallable listPornBatchDetectJobsCallable(const Model::ListPornBatchDetectJobsRequest& request) const;
 			DetectImageFacesOutcome detectImageFaces(const Model::DetectImageFacesRequest &request)const;
 			void detectImageFacesAsync(const Model::DetectImageFacesRequest& request, const DetectImageFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectImageFacesOutcomeCallable detectImageFacesCallable(const Model::DetectImageFacesRequest& request) const;
-			DetectImageTagsOutcome detectImageTags(const Model::DetectImageTagsRequest &request)const;
-			void detectImageTagsAsync(const Model::DetectImageTagsRequest& request, const DetectImageTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DetectImageTagsOutcomeCallable detectImageTagsCallable(const Model::DetectImageTagsRequest& request) const;
+			ListPornBatchDetectJobsOutcome listPornBatchDetectJobs(const Model::ListPornBatchDetectJobsRequest &request)const;
+			void listPornBatchDetectJobsAsync(const Model::ListPornBatchDetectJobsRequest& request, const ListPornBatchDetectJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListPornBatchDetectJobsOutcomeCallable listPornBatchDetectJobsCallable(const Model::ListPornBatchDetectJobsRequest& request) const;
 			DeleteImageOutcome deleteImage(const Model::DeleteImageRequest &request)const;
 			void deleteImageAsync(const Model::DeleteImageRequest& request, const DeleteImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteImageOutcomeCallable deleteImageCallable(const Model::DeleteImageRequest& request) const;
-			CreateTagJobOutcome createTagJob(const Model::CreateTagJobRequest &request)const;
-			void createTagJobAsync(const Model::CreateTagJobRequest& request, const CreateTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateTagJobOutcomeCallable createTagJobCallable(const Model::CreateTagJobRequest& request) const;
 			IndexTagOutcome indexTag(const Model::IndexTagRequest &request)const;
 			void indexTagAsync(const Model::IndexTagRequest& request, const IndexTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			IndexTagOutcomeCallable indexTagCallable(const Model::IndexTagRequest& request) const;
-			ListProjectsOutcome listProjects(const Model::ListProjectsRequest &request)const;
-			void listProjectsAsync(const Model::ListProjectsRequest& request, const ListProjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListProjectsOutcomeCallable listProjectsCallable(const Model::ListProjectsRequest& request) const;
-			DeleteSetOutcome deleteSet(const Model::DeleteSetRequest &request)const;
-			void deleteSetAsync(const Model::DeleteSetRequest& request, const DeleteSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteSetOutcomeCallable deleteSetCallable(const Model::DeleteSetRequest& request) const;
-			GetFaceSearchImageOutcome getFaceSearchImage(const Model::GetFaceSearchImageRequest &request)const;
-			void getFaceSearchImageAsync(const Model::GetFaceSearchImageRequest& request, const GetFaceSearchImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetFaceSearchImageOutcomeCallable getFaceSearchImageCallable(const Model::GetFaceSearchImageRequest& request) const;
+			CreateTagJobOutcome createTagJob(const Model::CreateTagJobRequest &request)const;
+			void createTagJobAsync(const Model::CreateTagJobRequest& request, const CreateTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateTagJobOutcomeCallable createTagJobCallable(const Model::CreateTagJobRequest& request) const;
 			CreateVideoAnalyseTaskOutcome createVideoAnalyseTask(const Model::CreateVideoAnalyseTaskRequest &request)const;
 			void createVideoAnalyseTaskAsync(const Model::CreateVideoAnalyseTaskRequest& request, const CreateVideoAnalyseTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateVideoAnalyseTaskOutcomeCallable createVideoAnalyseTaskCallable(const Model::CreateVideoAnalyseTaskRequest& request) const;
 			CompareFaceOutcome compareFace(const Model::CompareFaceRequest &request)const;
 			void compareFaceAsync(const Model::CompareFaceRequest& request, const CompareFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CompareFaceOutcomeCallable compareFaceCallable(const Model::CompareFaceRequest& request) const;
-			DetectTagOutcome detectTag(const Model::DetectTagRequest &request)const;
-			void detectTagAsync(const Model::DetectTagRequest& request, const DetectTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DetectTagOutcomeCallable detectTagCallable(const Model::DetectTagRequest& request) const;
 			ListFaceSearchGroupUsersOutcome listFaceSearchGroupUsers(const Model::ListFaceSearchGroupUsersRequest &request)const;
 			void listFaceSearchGroupUsersAsync(const Model::ListFaceSearchGroupUsersRequest& request, const ListFaceSearchGroupUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListFaceSearchGroupUsersOutcomeCallable listFaceSearchGroupUsersCallable(const Model::ListFaceSearchGroupUsersRequest& request) const;
 			ListFaceSearchGroupImagesOutcome listFaceSearchGroupImages(const Model::ListFaceSearchGroupImagesRequest &request)const;
 			void listFaceSearchGroupImagesAsync(const Model::ListFaceSearchGroupImagesRequest& request, const ListFaceSearchGroupImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListFaceSearchGroupImagesOutcomeCallable listFaceSearchGroupImagesCallable(const Model::ListFaceSearchGroupImagesRequest& request) const;
-			CreateCADConversionTaskOutcome createCADConversionTask(const Model::CreateCADConversionTaskRequest &request)const;
-			void createCADConversionTaskAsync(const Model::CreateCADConversionTaskRequest& request, const CreateCADConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateCADConversionTaskOutcomeCallable createCADConversionTaskCallable(const Model::CreateCADConversionTaskRequest& request) const;
-			GetTagJobOutcome getTagJob(const Model::GetTagJobRequest &request)const;
-			void getTagJobAsync(const Model::GetTagJobRequest& request, const GetTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetTagJobOutcomeCallable getTagJobCallable(const Model::GetTagJobRequest& request) const;
-			DeleteFaceJobOutcome deleteFaceJob(const Model::DeleteFaceJobRequest &request)const;
-			void deleteFaceJobAsync(const Model::DeleteFaceJobRequest& request, const DeleteFaceJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteFaceJobOutcomeCallable deleteFaceJobCallable(const Model::DeleteFaceJobRequest& request) const;
-			CreateDocIndexTaskOutcome createDocIndexTask(const Model::CreateDocIndexTaskRequest &request)const;
-			void createDocIndexTaskAsync(const Model::CreateDocIndexTaskRequest& request, const CreateDocIndexTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateDocIndexTaskOutcomeCallable createDocIndexTaskCallable(const Model::CreateDocIndexTaskRequest& request) const;
 			PutProjectOutcome putProject(const Model::PutProjectRequest &request)const;
 			void putProjectAsync(const Model::PutProjectRequest& request, const PutProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			PutProjectOutcomeCallable putProjectCallable(const Model::PutProjectRequest& request) const;
-			GetSetOutcome getSet(const Model::GetSetRequest &request)const;
-			void getSetAsync(const Model::GetSetRequest& request, const GetSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetSetOutcomeCallable getSetCallable(const Model::GetSetRequest& request) const;
-			GetVideoTaskOutcome getVideoTask(const Model::GetVideoTaskRequest &request)const;
-			void getVideoTaskAsync(const Model::GetVideoTaskRequest& request, const GetVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetVideoTaskOutcomeCallable getVideoTaskCallable(const Model::GetVideoTaskRequest& request) const;
 			ListSetsOutcome listSets(const Model::ListSetsRequest &request)const;
 			void listSetsAsync(const Model::ListSetsRequest& request, const ListSetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListSetsOutcomeCallable listSetsCallable(const Model::ListSetsRequest& request) const;
-			SearchDocIndexOutcome searchDocIndex(const Model::SearchDocIndexRequest &request)const;
-			void searchDocIndexAsync(const Model::SearchDocIndexRequest& request, const SearchDocIndexAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			SearchDocIndexOutcomeCallable searchDocIndexCallable(const Model::SearchDocIndexRequest& request) const;
-			ListPhotoProcessTasksOutcome listPhotoProcessTasks(const Model::ListPhotoProcessTasksRequest &request)const;
-			void listPhotoProcessTasksAsync(const Model::ListPhotoProcessTasksRequest& request, const ListPhotoProcessTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListPhotoProcessTasksOutcomeCallable listPhotoProcessTasksCallable(const Model::ListPhotoProcessTasksRequest& request) const;
-			ListVideosOutcome listVideos(const Model::ListVideosRequest &request)const;
-			void listVideosAsync(const Model::ListVideosRequest& request, const ListVideosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListVideosOutcomeCallable listVideosCallable(const Model::ListVideosRequest& request) const;
-			CreatePornBatchDetectJobOutcome createPornBatchDetectJob(const Model::CreatePornBatchDetectJobRequest &request)const;
-			void createPornBatchDetectJobAsync(const Model::CreatePornBatchDetectJobRequest& request, const CreatePornBatchDetectJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreatePornBatchDetectJobOutcomeCallable createPornBatchDetectJobCallable(const Model::CreatePornBatchDetectJobRequest& request) const;
 			FindImagesOutcome findImages(const Model::FindImagesRequest &request)const;
 			void findImagesAsync(const Model::FindImagesRequest& request, const FindImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			FindImagesOutcomeCallable findImagesCallable(const Model::FindImagesRequest& request) const;
-			DeleteTagByNameOutcome deleteTagByName(const Model::DeleteTagByNameRequest &request)const;
-			void deleteTagByNameAsync(const Model::DeleteTagByNameRequest& request, const DeleteTagByNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteTagByNameOutcomeCallable deleteTagByNameCallable(const Model::DeleteTagByNameRequest& request) const;
 			DetectImageLogosOutcome detectImageLogos(const Model::DetectImageLogosRequest &request)const;
 			void detectImageLogosAsync(const Model::DetectImageLogosRequest& request, const DetectImageLogosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectImageLogosOutcomeCallable detectImageLogosCallable(const Model::DetectImageLogosRequest& request) const;
 			GetProjectOutcome getProject(const Model::GetProjectRequest &request)const;
 			void getProjectAsync(const Model::GetProjectRequest& request, const GetProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetProjectOutcomeCallable getProjectCallable(const Model::GetProjectRequest& request) const;
-			DeletePhotoProcessTaskOutcome deletePhotoProcessTask(const Model::DeletePhotoProcessTaskRequest &request)const;
-			void deletePhotoProcessTaskAsync(const Model::DeletePhotoProcessTaskRequest& request, const DeletePhotoProcessTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeletePhotoProcessTaskOutcomeCallable deletePhotoProcessTaskCallable(const Model::DeletePhotoProcessTaskRequest& request) const;
-			ListSetTagsOutcome listSetTags(const Model::ListSetTagsRequest &request)const;
-			void listSetTagsAsync(const Model::ListSetTagsRequest& request, const ListSetTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListSetTagsOutcomeCallable listSetTagsCallable(const Model::ListSetTagsRequest& request) const;
-			DeleteVideoTaskOutcome deleteVideoTask(const Model::DeleteVideoTaskRequest &request)const;
-			void deleteVideoTaskAsync(const Model::DeleteVideoTaskRequest& request, const DeleteVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteVideoTaskOutcomeCallable deleteVideoTaskCallable(const Model::DeleteVideoTaskRequest& request) const;
-			FindImagesByTagNamesOutcome findImagesByTagNames(const Model::FindImagesByTagNamesRequest &request)const;
-			void findImagesByTagNamesAsync(const Model::FindImagesByTagNamesRequest& request, const FindImagesByTagNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			FindImagesByTagNamesOutcomeCallable findImagesByTagNamesCallable(const Model::FindImagesByTagNamesRequest& request) const;
 			DeleteTagSetOutcome deleteTagSet(const Model::DeleteTagSetRequest &request)const;
 			void deleteTagSetAsync(const Model::DeleteTagSetRequest& request, const DeleteTagSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteTagSetOutcomeCallable deleteTagSetCallable(const Model::DeleteTagSetRequest& request) const;
@@ -630,42 +580,165 @@ namespace AlibabaCloud
 			SearchFaceOutcome searchFace(const Model::SearchFaceRequest &request)const;
 			void searchFaceAsync(const Model::SearchFaceRequest& request, const SearchFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SearchFaceOutcomeCallable searchFaceCallable(const Model::SearchFaceRequest& request) const;
-			GetImageOutcome getImage(const Model::GetImageRequest &request)const;
-			void getImageAsync(const Model::GetImageRequest& request, const GetImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetImageOutcomeCallable getImageCallable(const Model::GetImageRequest& request) const;
 			DetectImageCelebrityOutcome detectImageCelebrity(const Model::DetectImageCelebrityRequest &request)const;
 			void detectImageCelebrityAsync(const Model::DetectImageCelebrityRequest& request, const DetectImageCelebrityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectImageCelebrityOutcomeCallable detectImageCelebrityCallable(const Model::DetectImageCelebrityRequest& request) const;
-			CreateSetOutcome createSet(const Model::CreateSetRequest &request)const;
-			void createSetAsync(const Model::CreateSetRequest& request, const CreateSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateSetOutcomeCallable createSetCallable(const Model::CreateSetRequest& request) const;
-			DeletePornBatchDetectJobOutcome deletePornBatchDetectJob(const Model::DeletePornBatchDetectJobRequest &request)const;
-			void deletePornBatchDetectJobAsync(const Model::DeletePornBatchDetectJobRequest& request, const DeletePornBatchDetectJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeletePornBatchDetectJobOutcomeCallable deletePornBatchDetectJobCallable(const Model::DeletePornBatchDetectJobRequest& request) const;
 			ListFaceSearchGroupsOutcome listFaceSearchGroups(const Model::ListFaceSearchGroupsRequest &request)const;
 			void listFaceSearchGroupsAsync(const Model::ListFaceSearchGroupsRequest& request, const ListFaceSearchGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListFaceSearchGroupsOutcomeCallable listFaceSearchGroupsCallable(const Model::ListFaceSearchGroupsRequest& request) const;
 			GetTagSetOutcome getTagSet(const Model::GetTagSetRequest &request)const;
 			void getTagSetAsync(const Model::GetTagSetRequest& request, const GetTagSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetTagSetOutcomeCallable getTagSetCallable(const Model::GetTagSetRequest& request) const;
-			ConvertOfficeFormatOutcome convertOfficeFormat(const Model::ConvertOfficeFormatRequest &request)const;
-			void convertOfficeFormatAsync(const Model::ConvertOfficeFormatRequest& request, const ConvertOfficeFormatAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ConvertOfficeFormatOutcomeCallable convertOfficeFormatCallable(const Model::ConvertOfficeFormatRequest& request) const;
-			UpdateFaceGroupOutcome updateFaceGroup(const Model::UpdateFaceGroupRequest &request)const;
-			void updateFaceGroupAsync(const Model::UpdateFaceGroupRequest& request, const UpdateFaceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			UpdateFaceGroupOutcomeCallable updateFaceGroupCallable(const Model::UpdateFaceGroupRequest& request) const;
+			DeletePornBatchDetectJobOutcome deletePornBatchDetectJob(const Model::DeletePornBatchDetectJobRequest &request)const;
+			void deletePornBatchDetectJobAsync(const Model::DeletePornBatchDetectJobRequest& request, const DeletePornBatchDetectJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeletePornBatchDetectJobOutcomeCallable deletePornBatchDetectJobCallable(const Model::DeletePornBatchDetectJobRequest& request) const;
 			ListTagPhotosOutcome listTagPhotos(const Model::ListTagPhotosRequest &request)const;
 			void listTagPhotosAsync(const Model::ListTagPhotosRequest& request, const ListTagPhotosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTagPhotosOutcomeCallable listTagPhotosCallable(const Model::ListTagPhotosRequest& request) const;
-			DetectImageBodiesOutcome detectImageBodies(const Model::DetectImageBodiesRequest &request)const;
-			void detectImageBodiesAsync(const Model::DetectImageBodiesRequest& request, const DetectImageBodiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DetectImageBodiesOutcomeCallable detectImageBodiesCallable(const Model::DetectImageBodiesRequest& request) const;
 			DeleteFaceSearchImageByIdOutcome deleteFaceSearchImageById(const Model::DeleteFaceSearchImageByIdRequest &request)const;
 			void deleteFaceSearchImageByIdAsync(const Model::DeleteFaceSearchImageByIdRequest& request, const DeleteFaceSearchImageByIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteFaceSearchImageByIdOutcomeCallable deleteFaceSearchImageByIdCallable(const Model::DeleteFaceSearchImageByIdRequest& request) const;
 			IndexVideoOutcome indexVideo(const Model::IndexVideoRequest &request)const;
 			void indexVideoAsync(const Model::IndexVideoRequest& request, const IndexVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			IndexVideoOutcomeCallable indexVideoCallable(const Model::IndexVideoRequest& request) const;
+			ListVideoAudiosOutcome listVideoAudios(const Model::ListVideoAudiosRequest &request)const;
+			void listVideoAudiosAsync(const Model::ListVideoAudiosRequest& request, const ListVideoAudiosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVideoAudiosOutcomeCallable listVideoAudiosCallable(const Model::ListVideoAudiosRequest& request) const;
+			CreateMergeFaceGroupsJobOutcome createMergeFaceGroupsJob(const Model::CreateMergeFaceGroupsJobRequest &request)const;
+			void createMergeFaceGroupsJobAsync(const Model::CreateMergeFaceGroupsJobRequest& request, const CreateMergeFaceGroupsJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateMergeFaceGroupsJobOutcomeCallable createMergeFaceGroupsJobCallable(const Model::CreateMergeFaceGroupsJobRequest& request) const;
+			ListTagNamesOutcome listTagNames(const Model::ListTagNamesRequest &request)const;
+			void listTagNamesAsync(const Model::ListTagNamesRequest& request, const ListTagNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagNamesOutcomeCallable listTagNamesCallable(const Model::ListTagNamesRequest& request) const;
+			CreateOfficeConversionTaskOutcome createOfficeConversionTask(const Model::CreateOfficeConversionTaskRequest &request)const;
+			void createOfficeConversionTaskAsync(const Model::CreateOfficeConversionTaskRequest& request, const CreateOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateOfficeConversionTaskOutcomeCallable createOfficeConversionTaskCallable(const Model::CreateOfficeConversionTaskRequest& request) const;
+			GetFaceSearchGroupOutcome getFaceSearchGroup(const Model::GetFaceSearchGroupRequest &request)const;
+			void getFaceSearchGroupAsync(const Model::GetFaceSearchGroupRequest& request, const GetFaceSearchGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFaceSearchGroupOutcomeCallable getFaceSearchGroupCallable(const Model::GetFaceSearchGroupRequest& request) const;
+			CompareImageFacesOutcome compareImageFaces(const Model::CompareImageFacesRequest &request)const;
+			void compareImageFacesAsync(const Model::CompareImageFacesRequest& request, const CompareImageFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CompareImageFacesOutcomeCallable compareImageFacesCallable(const Model::CompareImageFacesRequest& request) const;
+			DeleteTagJobOutcome deleteTagJob(const Model::DeleteTagJobRequest &request)const;
+			void deleteTagJobAsync(const Model::DeleteTagJobRequest& request, const DeleteTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteTagJobOutcomeCallable deleteTagJobCallable(const Model::DeleteTagJobRequest& request) const;
+			PhotoProcessOutcome photoProcess(const Model::PhotoProcessRequest &request)const;
+			void photoProcessAsync(const Model::PhotoProcessRequest& request, const PhotoProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PhotoProcessOutcomeCallable photoProcessCallable(const Model::PhotoProcessRequest& request) const;
+			DeleteFaceSearchUserOutcome deleteFaceSearchUser(const Model::DeleteFaceSearchUserRequest &request)const;
+			void deleteFaceSearchUserAsync(const Model::DeleteFaceSearchUserRequest& request, const DeleteFaceSearchUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFaceSearchUserOutcomeCallable deleteFaceSearchUserCallable(const Model::DeleteFaceSearchUserRequest& request) const;
+			GetOfficeConversionTaskOutcome getOfficeConversionTask(const Model::GetOfficeConversionTaskRequest &request)const;
+			void getOfficeConversionTaskAsync(const Model::GetOfficeConversionTaskRequest& request, const GetOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetOfficeConversionTaskOutcomeCallable getOfficeConversionTaskCallable(const Model::GetOfficeConversionTaskRequest& request) const;
+			RegistFaceOutcome registFace(const Model::RegistFaceRequest &request)const;
+			void registFaceAsync(const Model::RegistFaceRequest& request, const RegistFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RegistFaceOutcomeCallable registFaceCallable(const Model::RegistFaceRequest& request) const;
+			CreateTagSetOutcome createTagSet(const Model::CreateTagSetRequest &request)const;
+			void createTagSetAsync(const Model::CreateTagSetRequest& request, const CreateTagSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateTagSetOutcomeCallable createTagSetCallable(const Model::CreateTagSetRequest& request) const;
+			GetFaceSearchUserOutcome getFaceSearchUser(const Model::GetFaceSearchUserRequest &request)const;
+			void getFaceSearchUserAsync(const Model::GetFaceSearchUserRequest& request, const GetFaceSearchUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFaceSearchUserOutcomeCallable getFaceSearchUserCallable(const Model::GetFaceSearchUserRequest& request) const;
+			CreateFaceSetOutcome createFaceSet(const Model::CreateFaceSetRequest &request)const;
+			void createFaceSetAsync(const Model::CreateFaceSetRequest& request, const CreateFaceSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateFaceSetOutcomeCallable createFaceSetCallable(const Model::CreateFaceSetRequest& request) const;
+			ListProjectAPIsOutcome listProjectAPIs(const Model::ListProjectAPIsRequest &request)const;
+			void listProjectAPIsAsync(const Model::ListProjectAPIsRequest& request, const ListProjectAPIsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListProjectAPIsOutcomeCallable listProjectAPIsCallable(const Model::ListProjectAPIsRequest& request) const;
+			DetectImageTextsOutcome detectImageTexts(const Model::DetectImageTextsRequest &request)const;
+			void detectImageTextsAsync(const Model::DetectImageTextsRequest& request, const DetectImageTextsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectImageTextsOutcomeCallable detectImageTextsCallable(const Model::DetectImageTextsRequest& request) const;
+			CreateGroupFacesJobOutcome createGroupFacesJob(const Model::CreateGroupFacesJobRequest &request)const;
+			void createGroupFacesJobAsync(const Model::CreateGroupFacesJobRequest& request, const CreateGroupFacesJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGroupFacesJobOutcomeCallable createGroupFacesJobCallable(const Model::CreateGroupFacesJobRequest& request) const;
+			DeleteVideoOutcome deleteVideo(const Model::DeleteVideoRequest &request)const;
+			void deleteVideoAsync(const Model::DeleteVideoRequest& request, const DeleteVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVideoOutcomeCallable deleteVideoCallable(const Model::DeleteVideoRequest& request) const;
+			ListOfficeConversionTaskOutcome listOfficeConversionTask(const Model::ListOfficeConversionTaskRequest &request)const;
+			void listOfficeConversionTaskAsync(const Model::ListOfficeConversionTaskRequest& request, const ListOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListOfficeConversionTaskOutcomeCallable listOfficeConversionTaskCallable(const Model::ListOfficeConversionTaskRequest& request) const;
+			ListFaceGroupsOutcome listFaceGroups(const Model::ListFaceGroupsRequest &request)const;
+			void listFaceGroupsAsync(const Model::ListFaceGroupsRequest& request, const ListFaceGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFaceGroupsOutcomeCallable listFaceGroupsCallable(const Model::ListFaceGroupsRequest& request) const;
+			DetectImageTagsOutcome detectImageTags(const Model::DetectImageTagsRequest &request)const;
+			void detectImageTagsAsync(const Model::DetectImageTagsRequest& request, const DetectImageTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectImageTagsOutcomeCallable detectImageTagsCallable(const Model::DetectImageTagsRequest& request) const;
+			ListProjectsOutcome listProjects(const Model::ListProjectsRequest &request)const;
+			void listProjectsAsync(const Model::ListProjectsRequest& request, const ListProjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListProjectsOutcomeCallable listProjectsCallable(const Model::ListProjectsRequest& request) const;
+			DeleteSetOutcome deleteSet(const Model::DeleteSetRequest &request)const;
+			void deleteSetAsync(const Model::DeleteSetRequest& request, const DeleteSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSetOutcomeCallable deleteSetCallable(const Model::DeleteSetRequest& request) const;
+			GetFaceSearchImageOutcome getFaceSearchImage(const Model::GetFaceSearchImageRequest &request)const;
+			void getFaceSearchImageAsync(const Model::GetFaceSearchImageRequest& request, const GetFaceSearchImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFaceSearchImageOutcomeCallable getFaceSearchImageCallable(const Model::GetFaceSearchImageRequest& request) const;
+			DetectTagOutcome detectTag(const Model::DetectTagRequest &request)const;
+			void detectTagAsync(const Model::DetectTagRequest& request, const DetectTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectTagOutcomeCallable detectTagCallable(const Model::DetectTagRequest& request) const;
+			CreateCADConversionTaskOutcome createCADConversionTask(const Model::CreateCADConversionTaskRequest &request)const;
+			void createCADConversionTaskAsync(const Model::CreateCADConversionTaskRequest& request, const CreateCADConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCADConversionTaskOutcomeCallable createCADConversionTaskCallable(const Model::CreateCADConversionTaskRequest& request) const;
+			GetTagJobOutcome getTagJob(const Model::GetTagJobRequest &request)const;
+			void getTagJobAsync(const Model::GetTagJobRequest& request, const GetTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTagJobOutcomeCallable getTagJobCallable(const Model::GetTagJobRequest& request) const;
+			DeleteFaceJobOutcome deleteFaceJob(const Model::DeleteFaceJobRequest &request)const;
+			void deleteFaceJobAsync(const Model::DeleteFaceJobRequest& request, const DeleteFaceJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFaceJobOutcomeCallable deleteFaceJobCallable(const Model::DeleteFaceJobRequest& request) const;
+			CreateDocIndexTaskOutcome createDocIndexTask(const Model::CreateDocIndexTaskRequest &request)const;
+			void createDocIndexTaskAsync(const Model::CreateDocIndexTaskRequest& request, const CreateDocIndexTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDocIndexTaskOutcomeCallable createDocIndexTaskCallable(const Model::CreateDocIndexTaskRequest& request) const;
+			GetVideoTaskOutcome getVideoTask(const Model::GetVideoTaskRequest &request)const;
+			void getVideoTaskAsync(const Model::GetVideoTaskRequest& request, const GetVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVideoTaskOutcomeCallable getVideoTaskCallable(const Model::GetVideoTaskRequest& request) const;
+			GetSetOutcome getSet(const Model::GetSetRequest &request)const;
+			void getSetAsync(const Model::GetSetRequest& request, const GetSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetSetOutcomeCallable getSetCallable(const Model::GetSetRequest& request) const;
+			SearchDocIndexOutcome searchDocIndex(const Model::SearchDocIndexRequest &request)const;
+			void searchDocIndexAsync(const Model::SearchDocIndexRequest& request, const SearchDocIndexAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SearchDocIndexOutcomeCallable searchDocIndexCallable(const Model::SearchDocIndexRequest& request) const;
+			ListPhotoProcessTasksOutcome listPhotoProcessTasks(const Model::ListPhotoProcessTasksRequest &request)const;
+			void listPhotoProcessTasksAsync(const Model::ListPhotoProcessTasksRequest& request, const ListPhotoProcessTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListPhotoProcessTasksOutcomeCallable listPhotoProcessTasksCallable(const Model::ListPhotoProcessTasksRequest& request) const;
+			ListVideosOutcome listVideos(const Model::ListVideosRequest &request)const;
+			void listVideosAsync(const Model::ListVideosRequest& request, const ListVideosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVideosOutcomeCallable listVideosCallable(const Model::ListVideosRequest& request) const;
+			CreatePornBatchDetectJobOutcome createPornBatchDetectJob(const Model::CreatePornBatchDetectJobRequest &request)const;
+			void createPornBatchDetectJobAsync(const Model::CreatePornBatchDetectJobRequest& request, const CreatePornBatchDetectJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreatePornBatchDetectJobOutcomeCallable createPornBatchDetectJobCallable(const Model::CreatePornBatchDetectJobRequest& request) const;
+			DeleteTagByNameOutcome deleteTagByName(const Model::DeleteTagByNameRequest &request)const;
+			void deleteTagByNameAsync(const Model::DeleteTagByNameRequest& request, const DeleteTagByNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteTagByNameOutcomeCallable deleteTagByNameCallable(const Model::DeleteTagByNameRequest& request) const;
+			DeletePhotoProcessTaskOutcome deletePhotoProcessTask(const Model::DeletePhotoProcessTaskRequest &request)const;
+			void deletePhotoProcessTaskAsync(const Model::DeletePhotoProcessTaskRequest& request, const DeletePhotoProcessTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeletePhotoProcessTaskOutcomeCallable deletePhotoProcessTaskCallable(const Model::DeletePhotoProcessTaskRequest& request) const;
+			ListSetTagsOutcome listSetTags(const Model::ListSetTagsRequest &request)const;
+			void listSetTagsAsync(const Model::ListSetTagsRequest& request, const ListSetTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSetTagsOutcomeCallable listSetTagsCallable(const Model::ListSetTagsRequest& request) const;
+			DeleteVideoTaskOutcome deleteVideoTask(const Model::DeleteVideoTaskRequest &request)const;
+			void deleteVideoTaskAsync(const Model::DeleteVideoTaskRequest& request, const DeleteVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVideoTaskOutcomeCallable deleteVideoTaskCallable(const Model::DeleteVideoTaskRequest& request) const;
+			FindImagesByTagNamesOutcome findImagesByTagNames(const Model::FindImagesByTagNamesRequest &request)const;
+			void findImagesByTagNamesAsync(const Model::FindImagesByTagNamesRequest& request, const FindImagesByTagNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FindImagesByTagNamesOutcomeCallable findImagesByTagNamesCallable(const Model::FindImagesByTagNamesRequest& request) const;
+			GetImageOutcome getImage(const Model::GetImageRequest &request)const;
+			void getImageAsync(const Model::GetImageRequest& request, const GetImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetImageOutcomeCallable getImageCallable(const Model::GetImageRequest& request) const;
+			GetMediaMetaOutcome getMediaMeta(const Model::GetMediaMetaRequest &request)const;
+			void getMediaMetaAsync(const Model::GetMediaMetaRequest& request, const GetMediaMetaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMediaMetaOutcomeCallable getMediaMetaCallable(const Model::GetMediaMetaRequest& request) const;
+			CreateSetOutcome createSet(const Model::CreateSetRequest &request)const;
+			void createSetAsync(const Model::CreateSetRequest& request, const CreateSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateSetOutcomeCallable createSetCallable(const Model::CreateSetRequest& request) const;
+			ConvertOfficeFormatOutcome convertOfficeFormat(const Model::ConvertOfficeFormatRequest &request)const;
+			void convertOfficeFormatAsync(const Model::ConvertOfficeFormatRequest& request, const ConvertOfficeFormatAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ConvertOfficeFormatOutcomeCallable convertOfficeFormatCallable(const Model::ConvertOfficeFormatRequest& request) const;
+			UpdateFaceGroupOutcome updateFaceGroup(const Model::UpdateFaceGroupRequest &request)const;
+			void updateFaceGroupAsync(const Model::UpdateFaceGroupRequest& request, const UpdateFaceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateFaceGroupOutcomeCallable updateFaceGroupCallable(const Model::UpdateFaceGroupRequest& request) const;
+			DetectImageBodiesOutcome detectImageBodies(const Model::DetectImageBodiesRequest &request)const;
+			void detectImageBodiesAsync(const Model::DetectImageBodiesRequest& request, const DetectImageBodiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectImageBodiesOutcomeCallable detectImageBodiesCallable(const Model::DetectImageBodiesRequest& request) const;
 			DeleteDocIndexOutcome deleteDocIndex(const Model::DeleteDocIndexRequest &request)const;
 			void deleteDocIndexAsync(const Model::DeleteDocIndexRequest& request, const DeleteDocIndexAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDocIndexOutcomeCallable deleteDocIndexCallable(const Model::DeleteDocIndexRequest& request) const;
@@ -675,48 +748,24 @@ namespace AlibabaCloud
 			GetImageJobOutcome getImageJob(const Model::GetImageJobRequest &request)const;
 			void getImageJobAsync(const Model::GetImageJobRequest& request, const GetImageJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetImageJobOutcomeCallable getImageJobCallable(const Model::GetImageJobRequest& request) const;
-			ListVideoAudiosOutcome listVideoAudios(const Model::ListVideoAudiosRequest &request)const;
-			void listVideoAudiosAsync(const Model::ListVideoAudiosRequest& request, const ListVideoAudiosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListVideoAudiosOutcomeCallable listVideoAudiosCallable(const Model::ListVideoAudiosRequest& request) const;
-			CreateMergeFaceGroupsJobOutcome createMergeFaceGroupsJob(const Model::CreateMergeFaceGroupsJobRequest &request)const;
-			void createMergeFaceGroupsJobAsync(const Model::CreateMergeFaceGroupsJobRequest& request, const CreateMergeFaceGroupsJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateMergeFaceGroupsJobOutcomeCallable createMergeFaceGroupsJobCallable(const Model::CreateMergeFaceGroupsJobRequest& request) const;
 			DeleteTagByUrlOutcome deleteTagByUrl(const Model::DeleteTagByUrlRequest &request)const;
 			void deleteTagByUrlAsync(const Model::DeleteTagByUrlRequest& request, const DeleteTagByUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteTagByUrlOutcomeCallable deleteTagByUrlCallable(const Model::DeleteTagByUrlRequest& request) const;
 			ListTagSetsOutcome listTagSets(const Model::ListTagSetsRequest &request)const;
 			void listTagSetsAsync(const Model::ListTagSetsRequest& request, const ListTagSetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTagSetsOutcomeCallable listTagSetsCallable(const Model::ListTagSetsRequest& request) const;
-			ListTagNamesOutcome listTagNames(const Model::ListTagNamesRequest &request)const;
-			void listTagNamesAsync(const Model::ListTagNamesRequest& request, const ListTagNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListTagNamesOutcomeCallable listTagNamesCallable(const Model::ListTagNamesRequest& request) const;
-			CreateOfficeConversionTaskOutcome createOfficeConversionTask(const Model::CreateOfficeConversionTaskRequest &request)const;
-			void createOfficeConversionTaskAsync(const Model::CreateOfficeConversionTaskRequest& request, const CreateOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateOfficeConversionTaskOutcomeCallable createOfficeConversionTaskCallable(const Model::CreateOfficeConversionTaskRequest& request) const;
 			DetectQRCodesOutcome detectQRCodes(const Model::DetectQRCodesRequest &request)const;
 			void detectQRCodesAsync(const Model::DetectQRCodesRequest& request, const DetectQRCodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectQRCodesOutcomeCallable detectQRCodesCallable(const Model::DetectQRCodesRequest& request) const;
-			GetFaceSearchGroupOutcome getFaceSearchGroup(const Model::GetFaceSearchGroupRequest &request)const;
-			void getFaceSearchGroupAsync(const Model::GetFaceSearchGroupRequest& request, const GetFaceSearchGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetFaceSearchGroupOutcomeCallable getFaceSearchGroupCallable(const Model::GetFaceSearchGroupRequest& request) const;
 			GetVideoOutcome getVideo(const Model::GetVideoRequest &request)const;
 			void getVideoAsync(const Model::GetVideoRequest& request, const GetVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetVideoOutcomeCallable getVideoCallable(const Model::GetVideoRequest& request) const;
 			ListImagesOutcome listImages(const Model::ListImagesRequest &request)const;
 			void listImagesAsync(const Model::ListImagesRequest& request, const ListImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListImagesOutcomeCallable listImagesCallable(const Model::ListImagesRequest& request) const;
-			CompareImageFacesOutcome compareImageFaces(const Model::CompareImageFacesRequest &request)const;
-			void compareImageFacesAsync(const Model::CompareImageFacesRequest& request, const CompareImageFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CompareImageFacesOutcomeCallable compareImageFacesCallable(const Model::CompareImageFacesRequest& request) const;
-			DeleteTagJobOutcome deleteTagJob(const Model::DeleteTagJobRequest &request)const;
-			void deleteTagJobAsync(const Model::DeleteTagJobRequest& request, const DeleteTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteTagJobOutcomeCallable deleteTagJobCallable(const Model::DeleteTagJobRequest& request) const;
 			DeleteOfficeConversionTaskOutcome deleteOfficeConversionTask(const Model::DeleteOfficeConversionTaskRequest &request)const;
 			void deleteOfficeConversionTaskAsync(const Model::DeleteOfficeConversionTaskRequest& request, const DeleteOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteOfficeConversionTaskOutcomeCallable deleteOfficeConversionTaskCallable(const Model::DeleteOfficeConversionTaskRequest& request) const;
-			PhotoProcessOutcome photoProcess(const Model::PhotoProcessRequest &request)const;
-			void photoProcessAsync(const Model::PhotoProcessRequest& request, const PhotoProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			PhotoProcessOutcomeCallable photoProcessCallable(const Model::PhotoProcessRequest& request) const;
 			GetPhotoProcessTaskOutcome getPhotoProcessTask(const Model::GetPhotoProcessTaskRequest &request)const;
 			void getPhotoProcessTaskAsync(const Model::GetPhotoProcessTaskRequest& request, const GetPhotoProcessTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetPhotoProcessTaskOutcomeCallable getPhotoProcessTaskCallable(const Model::GetPhotoProcessTaskRequest& request) const;
@@ -726,42 +775,24 @@ namespace AlibabaCloud
 			GetPornBatchDetectJobOutcome getPornBatchDetectJob(const Model::GetPornBatchDetectJobRequest &request)const;
 			void getPornBatchDetectJobAsync(const Model::GetPornBatchDetectJobRequest& request, const GetPornBatchDetectJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetPornBatchDetectJobOutcomeCallable getPornBatchDetectJobCallable(const Model::GetPornBatchDetectJobRequest& request) const;
-			DetectLogoOutcome detectLogo(const Model::DetectLogoRequest &request)const;
-			void detectLogoAsync(const Model::DetectLogoRequest& request, const DetectLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DetectLogoOutcomeCallable detectLogoCallable(const Model::DetectLogoRequest& request) const;
-			DetectClothesOutcome detectClothes(const Model::DetectClothesRequest &request)const;
-			void detectClothesAsync(const Model::DetectClothesRequest& request, const DetectClothesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DetectClothesOutcomeCallable detectClothesCallable(const Model::DetectClothesRequest& request) const;
 			ListTagJobsOutcome listTagJobs(const Model::ListTagJobsRequest &request)const;
 			void listTagJobsAsync(const Model::ListTagJobsRequest& request, const ListTagJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTagJobsOutcomeCallable listTagJobsCallable(const Model::ListTagJobsRequest& request) const;
+			DetectClothesOutcome detectClothes(const Model::DetectClothesRequest &request)const;
+			void detectClothesAsync(const Model::DetectClothesRequest& request, const DetectClothesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectClothesOutcomeCallable detectClothesCallable(const Model::DetectClothesRequest& request) const;
+			DetectLogoOutcome detectLogo(const Model::DetectLogoRequest &request)const;
+			void detectLogoAsync(const Model::DetectLogoRequest& request, const DetectLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectLogoOutcomeCallable detectLogoCallable(const Model::DetectLogoRequest& request) const;
 			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
 			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
-			DeleteFaceSearchUserOutcome deleteFaceSearchUser(const Model::DeleteFaceSearchUserRequest &request)const;
-			void deleteFaceSearchUserAsync(const Model::DeleteFaceSearchUserRequest& request, const DeleteFaceSearchUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteFaceSearchUserOutcomeCallable deleteFaceSearchUserCallable(const Model::DeleteFaceSearchUserRequest& request) const;
-			GetOfficeConversionTaskOutcome getOfficeConversionTask(const Model::GetOfficeConversionTaskRequest &request)const;
-			void getOfficeConversionTaskAsync(const Model::GetOfficeConversionTaskRequest& request, const GetOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetOfficeConversionTaskOutcomeCallable getOfficeConversionTaskCallable(const Model::GetOfficeConversionTaskRequest& request) const;
-			CreateTagSetOutcome createTagSet(const Model::CreateTagSetRequest &request)const;
-			void createTagSetAsync(const Model::CreateTagSetRequest& request, const CreateTagSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateTagSetOutcomeCallable createTagSetCallable(const Model::CreateTagSetRequest& request) const;
-			RegistFaceOutcome registFace(const Model::RegistFaceRequest &request)const;
-			void registFaceAsync(const Model::RegistFaceRequest& request, const RegistFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			RegistFaceOutcomeCallable registFaceCallable(const Model::RegistFaceRequest& request) const;
 			FindSimilarFacesOutcome findSimilarFaces(const Model::FindSimilarFacesRequest &request)const;
 			void findSimilarFacesAsync(const Model::FindSimilarFacesRequest& request, const FindSimilarFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			FindSimilarFacesOutcomeCallable findSimilarFacesCallable(const Model::FindSimilarFacesRequest& request) const;
-			GetFaceSearchUserOutcome getFaceSearchUser(const Model::GetFaceSearchUserRequest &request)const;
-			void getFaceSearchUserAsync(const Model::GetFaceSearchUserRequest& request, const GetFaceSearchUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetFaceSearchUserOutcomeCallable getFaceSearchUserCallable(const Model::GetFaceSearchUserRequest& request) const;
 			DeleteImageJobOutcome deleteImageJob(const Model::DeleteImageJobRequest &request)const;
 			void deleteImageJobAsync(const Model::DeleteImageJobRequest& request, const DeleteImageJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteImageJobOutcomeCallable deleteImageJobCallable(const Model::DeleteImageJobRequest& request) const;
-			CreateFaceSetOutcome createFaceSet(const Model::CreateFaceSetRequest &request)const;
-			void createFaceSetAsync(const Model::CreateFaceSetRequest& request, const CreateFaceSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateFaceSetOutcomeCallable createFaceSetCallable(const Model::CreateFaceSetRequest& request) const;
 			DeleteFaceSearchGroupOutcome deleteFaceSearchGroup(const Model::DeleteFaceSearchGroupRequest &request)const;
 			void deleteFaceSearchGroupAsync(const Model::DeleteFaceSearchGroupRequest& request, const DeleteFaceSearchGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteFaceSearchGroupOutcomeCallable deleteFaceSearchGroupCallable(const Model::DeleteFaceSearchGroupRequest& request) const;
@@ -771,15 +802,9 @@ namespace AlibabaCloud
 			IndexImageOutcome indexImage(const Model::IndexImageRequest &request)const;
 			void indexImageAsync(const Model::IndexImageRequest& request, const IndexImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			IndexImageOutcomeCallable indexImageCallable(const Model::IndexImageRequest& request) const;
-			DetectImageTextsOutcome detectImageTexts(const Model::DetectImageTextsRequest &request)const;
-			void detectImageTextsAsync(const Model::DetectImageTextsRequest& request, const DetectImageTextsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DetectImageTextsOutcomeCallable detectImageTextsCallable(const Model::DetectImageTextsRequest& request) const;
 			ListImageJobsOutcome listImageJobs(const Model::ListImageJobsRequest &request)const;
 			void listImageJobsAsync(const Model::ListImageJobsRequest& request, const ListImageJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListImageJobsOutcomeCallable listImageJobsCallable(const Model::ListImageJobsRequest& request) const;
-			CreateGroupFacesJobOutcome createGroupFacesJob(const Model::CreateGroupFacesJobRequest &request)const;
-			void createGroupFacesJobAsync(const Model::CreateGroupFacesJobRequest& request, const CreateGroupFacesJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateGroupFacesJobOutcomeCallable createGroupFacesJobCallable(const Model::CreateGroupFacesJobRequest& request) const;
 			UpdateImageOutcome updateImage(const Model::UpdateImageRequest &request)const;
 			void updateImageAsync(const Model::UpdateImageRequest& request, const UpdateImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateImageOutcomeCallable updateImageCallable(const Model::UpdateImageRequest& request) const;
@@ -792,18 +817,9 @@ namespace AlibabaCloud
 			UpdateProjectOutcome updateProject(const Model::UpdateProjectRequest &request)const;
 			void updateProjectAsync(const Model::UpdateProjectRequest& request, const UpdateProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateProjectOutcomeCallable updateProjectCallable(const Model::UpdateProjectRequest& request) const;
-			DeleteVideoOutcome deleteVideo(const Model::DeleteVideoRequest &request)const;
-			void deleteVideoAsync(const Model::DeleteVideoRequest& request, const DeleteVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteVideoOutcomeCallable deleteVideoCallable(const Model::DeleteVideoRequest& request) const;
-			ListOfficeConversionTaskOutcome listOfficeConversionTask(const Model::ListOfficeConversionTaskRequest &request)const;
-			void listOfficeConversionTaskAsync(const Model::ListOfficeConversionTaskRequest& request, const ListOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListOfficeConversionTaskOutcomeCallable listOfficeConversionTaskCallable(const Model::ListOfficeConversionTaskRequest& request) const;
 			UpdateSetOutcome updateSet(const Model::UpdateSetRequest &request)const;
 			void updateSetAsync(const Model::UpdateSetRequest& request, const UpdateSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateSetOutcomeCallable updateSetCallable(const Model::UpdateSetRequest& request) const;
-			ListFaceGroupsOutcome listFaceGroups(const Model::ListFaceGroupsRequest &request)const;
-			void listFaceGroupsAsync(const Model::ListFaceGroupsRequest& request, const ListFaceGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListFaceGroupsOutcomeCallable listFaceGroupsCallable(const Model::ListFaceGroupsRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;
diff --git a/imm/include/alibabacloud/imm/model/GetMediaMetaRequest.h b/imm/include/alibabacloud/imm/model/GetMediaMetaRequest.h
new file mode 100644
index 000000000..faddf97ce
--- /dev/null
+++ b/imm/include/alibabacloud/imm/model/GetMediaMetaRequest.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMM_MODEL_GETMEDIAMETAREQUEST_H_
+#define ALIBABACLOUD_IMM_MODEL_GETMEDIAMETAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imm/ImmExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imm
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMM_EXPORT GetMediaMetaRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetMediaMetaRequest();
+				~GetMediaMetaRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getMediaUri()const;
+				void setMediaUri(const std::string& mediaUri);
+				std::string getProject()const;
+				void setProject(const std::string& project);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string regionId_;
+				std::string mediaUri_;
+				std::string project_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMM_MODEL_GETMEDIAMETAREQUEST_H_
\ No newline at end of file
diff --git a/imm/include/alibabacloud/imm/model/GetMediaMetaResult.h b/imm/include/alibabacloud/imm/model/GetMediaMetaResult.h
new file mode 100644
index 000000000..20b3a294e
--- /dev/null
+++ b/imm/include/alibabacloud/imm/model/GetMediaMetaResult.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMM_MODEL_GETMEDIAMETARESULT_H_
+#define ALIBABACLOUD_IMM_MODEL_GETMEDIAMETARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imm/ImmExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imm
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMM_EXPORT GetMediaMetaResult : public ServiceResult
+			{
+			public:
+				struct MediaMeta
+				{
+					struct MediaFormat
+					{
+						int numberStreams;
+						std::string size;
+						std::string formatLongName;
+						std::string startTime;
+						std::string creationTime;
+						std::string formatName;
+						std::string duration;
+						std::string bitrate;
+						int numberPrograms;
+						std::string location;
+					};
+					struct MediaStreams
+					{
+						struct VideoStream
+						{
+							std::string codecTag;
+							std::string frames;
+							std::string codecTimeBase;
+							std::string sampleAspectRatio;
+							std::string startTime;
+							int index;
+							std::string duration;
+							std::string codecName;
+							std::string bitrate;
+							std::string profile;
+							std::string displayAspectRatio;
+							std::string codecTagString;
+							int hasBFrames;
+							std::string averageFrameRate;
+							std::string language;
+							std::string codecLongName;
+							int height;
+							std::string pixelFormat;
+							int level;
+							std::string frameRrate;
+							int width;
+							std::string timeBase;
+						};
+						struct AudioStream
+						{
+							std::string codecTag;
+							std::string frames;
+							std::string codecTimeBase;
+							std::string channelLayout;
+							std::string startTime;
+							int index;
+							std::string duration;
+							std::string codecName;
+							std::string bitrate;
+							std::string sampleFormat;
+							int channels;
+							std::string codecTagString;
+							std::string sampleRate;
+							std::string language;
+							std::string codecLongName;
+							std::string timeBase;
+						};
+						struct SubtitleStream
+						{
+							std::string language;
+							int index;
+						};
+						std::vector<VideoStream> videoStreams;
+						std::vector<SubtitleStream> subtitleStreams;
+						std::vector<AudioStream> audioStreams;
+					};
+					MediaFormat mediaFormat;
+					MediaStreams mediaStreams;
+				};
+
+
+				GetMediaMetaResult();
+				explicit GetMediaMetaResult(const std::string &payload);
+				~GetMediaMetaResult();
+				std::string getMediaUri()const;
+				MediaMeta getMediaMeta()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string mediaUri_;
+				MediaMeta mediaMeta_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMM_MODEL_GETMEDIAMETARESULT_H_
\ No newline at end of file
diff --git a/imm/include/alibabacloud/imm/model/GetSetResult.h b/imm/include/alibabacloud/imm/model/GetSetResult.h
index 75e73bf8e..cbb92bb6a 100644
--- a/imm/include/alibabacloud/imm/model/GetSetResult.h
+++ b/imm/include/alibabacloud/imm/model/GetSetResult.h
@@ -37,10 +37,10 @@ namespace AlibabaCloud
 				GetSetResult();
 				explicit GetSetResult(const std::string &payload);
 				~GetSetResult();
-				long getModifyTime()const;
+				std::string getModifyTime()const;
 				int getImageCount()const;
 				int getVideoCount()const;
-				long getCreateTime()const;
+				std::string getCreateTime()const;
 				std::string getSetName()const;
 				std::string getSetId()const;
 				int getFaceCount()const;
@@ -49,10 +49,10 @@ namespace AlibabaCloud
 			protected:
 				void parse(const std::string &payload);
 			private:
-				long modifyTime_;
+				std::string modifyTime_;
 				int imageCount_;
 				int videoCount_;
-				long createTime_;
+				std::string createTime_;
 				std::string setName_;
 				std::string setId_;
 				int faceCount_;
diff --git a/imm/include/alibabacloud/imm/model/ListProjectAPIsRequest.h b/imm/include/alibabacloud/imm/model/ListProjectAPIsRequest.h
new file mode 100644
index 000000000..caa405551
--- /dev/null
+++ b/imm/include/alibabacloud/imm/model/ListProjectAPIsRequest.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMM_MODEL_LISTPROJECTAPISREQUEST_H_
+#define ALIBABACLOUD_IMM_MODEL_LISTPROJECTAPISREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imm/ImmExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imm
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMM_EXPORT ListProjectAPIsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListProjectAPIsRequest();
+				~ListProjectAPIsRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getProject()const;
+				void setProject(const std::string& project);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string regionId_;
+				std::string project_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMM_MODEL_LISTPROJECTAPISREQUEST_H_
\ No newline at end of file
diff --git a/imm/include/alibabacloud/imm/model/ListProjectAPIsResult.h b/imm/include/alibabacloud/imm/model/ListProjectAPIsResult.h
new file mode 100644
index 000000000..2f7a03a1e
--- /dev/null
+++ b/imm/include/alibabacloud/imm/model/ListProjectAPIsResult.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMM_MODEL_LISTPROJECTAPISRESULT_H_
+#define ALIBABACLOUD_IMM_MODEL_LISTPROJECTAPISRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imm/ImmExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imm
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMM_EXPORT ListProjectAPIsResult : public ServiceResult
+			{
+			public:
+
+
+				ListProjectAPIsResult();
+				explicit ListProjectAPIsResult(const std::string &payload);
+				~ListProjectAPIsResult();
+				std::string getProject()const;
+				std::vector<std::string> getAPIs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string project_;
+				std::vector<std::string> aPIs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMM_MODEL_LISTPROJECTAPISRESULT_H_
\ No newline at end of file
diff --git a/imm/src/ImmClient.cc b/imm/src/ImmClient.cc
index 090d4c862..e2d23832f 100644
--- a/imm/src/ImmClient.cc
+++ b/imm/src/ImmClient.cc
@@ -51,42 +51,6 @@ ImmClient::ImmClient(const std::string & accessKeyId, const std::string & access
 ImmClient::~ImmClient()
 {}
 
-ImmClient::ListPornBatchDetectJobsOutcome ImmClient::listPornBatchDetectJobs(const ListPornBatchDetectJobsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListPornBatchDetectJobsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListPornBatchDetectJobsOutcome(ListPornBatchDetectJobsResult(outcome.result()));
-	else
-		return ListPornBatchDetectJobsOutcome(outcome.error());
-}
-
-void ImmClient::listPornBatchDetectJobsAsync(const ListPornBatchDetectJobsRequest& request, const ListPornBatchDetectJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listPornBatchDetectJobs(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::ListPornBatchDetectJobsOutcomeCallable ImmClient::listPornBatchDetectJobsCallable(const ListPornBatchDetectJobsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListPornBatchDetectJobsOutcome()>>(
-			[this, request]()
-			{
-			return this->listPornBatchDetectJobs(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DetectImageFacesOutcome ImmClient::detectImageFaces(const DetectImageFacesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -123,36 +87,36 @@ ImmClient::DetectImageFacesOutcomeCallable ImmClient::detectImageFacesCallable(c
 	return task->get_future();
 }
 
-ImmClient::DetectImageTagsOutcome ImmClient::detectImageTags(const DetectImageTagsRequest &request) const
+ImmClient::ListPornBatchDetectJobsOutcome ImmClient::listPornBatchDetectJobs(const ListPornBatchDetectJobsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DetectImageTagsOutcome(endpointOutcome.error());
+		return ListPornBatchDetectJobsOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DetectImageTagsOutcome(DetectImageTagsResult(outcome.result()));
+		return ListPornBatchDetectJobsOutcome(ListPornBatchDetectJobsResult(outcome.result()));
 	else
-		return DetectImageTagsOutcome(outcome.error());
+		return ListPornBatchDetectJobsOutcome(outcome.error());
 }
 
-void ImmClient::detectImageTagsAsync(const DetectImageTagsRequest& request, const DetectImageTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void ImmClient::listPornBatchDetectJobsAsync(const ListPornBatchDetectJobsRequest& request, const ListPornBatchDetectJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, detectImageTags(request), context);
+		handler(this, request, listPornBatchDetectJobs(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-ImmClient::DetectImageTagsOutcomeCallable ImmClient::detectImageTagsCallable(const DetectImageTagsRequest &request) const
+ImmClient::ListPornBatchDetectJobsOutcomeCallable ImmClient::listPornBatchDetectJobsCallable(const ListPornBatchDetectJobsRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DetectImageTagsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<ListPornBatchDetectJobsOutcome()>>(
 			[this, request]()
 			{
-			return this->detectImageTags(request);
+			return this->listPornBatchDetectJobs(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -195,42 +159,6 @@ ImmClient::DeleteImageOutcomeCallable ImmClient::deleteImageCallable(const Delet
 	return task->get_future();
 }
 
-ImmClient::CreateTagJobOutcome ImmClient::createTagJob(const CreateTagJobRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateTagJobOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateTagJobOutcome(CreateTagJobResult(outcome.result()));
-	else
-		return CreateTagJobOutcome(outcome.error());
-}
-
-void ImmClient::createTagJobAsync(const CreateTagJobRequest& request, const CreateTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createTagJob(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreateTagJobOutcomeCallable ImmClient::createTagJobCallable(const CreateTagJobRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateTagJobOutcome()>>(
-			[this, request]()
-			{
-			return this->createTagJob(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::IndexTagOutcome ImmClient::indexTag(const IndexTagRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,108 +195,36 @@ ImmClient::IndexTagOutcomeCallable ImmClient::indexTagCallable(const IndexTagReq
 	return task->get_future();
 }
 
-ImmClient::ListProjectsOutcome ImmClient::listProjects(const ListProjectsRequest &request) const
+ImmClient::CreateTagJobOutcome ImmClient::createTagJob(const CreateTagJobRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return ListProjectsOutcome(endpointOutcome.error());
+		return CreateTagJobOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return ListProjectsOutcome(ListProjectsResult(outcome.result()));
+		return CreateTagJobOutcome(CreateTagJobResult(outcome.result()));
 	else
-		return ListProjectsOutcome(outcome.error());
+		return CreateTagJobOutcome(outcome.error());
 }
 
-void ImmClient::listProjectsAsync(const ListProjectsRequest& request, const ListProjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void ImmClient::createTagJobAsync(const CreateTagJobRequest& request, const CreateTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, listProjects(request), context);
+		handler(this, request, createTagJob(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-ImmClient::ListProjectsOutcomeCallable ImmClient::listProjectsCallable(const ListProjectsRequest &request) const
+ImmClient::CreateTagJobOutcomeCallable ImmClient::createTagJobCallable(const CreateTagJobRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<ListProjectsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateTagJobOutcome()>>(
 			[this, request]()
 			{
-			return this->listProjects(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::DeleteSetOutcome ImmClient::deleteSet(const DeleteSetRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeleteSetOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeleteSetOutcome(DeleteSetResult(outcome.result()));
-	else
-		return DeleteSetOutcome(outcome.error());
-}
-
-void ImmClient::deleteSetAsync(const DeleteSetRequest& request, const DeleteSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deleteSet(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DeleteSetOutcomeCallable ImmClient::deleteSetCallable(const DeleteSetRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeleteSetOutcome()>>(
-			[this, request]()
-			{
-			return this->deleteSet(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::GetFaceSearchImageOutcome ImmClient::getFaceSearchImage(const GetFaceSearchImageRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return GetFaceSearchImageOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return GetFaceSearchImageOutcome(GetFaceSearchImageResult(outcome.result()));
-	else
-		return GetFaceSearchImageOutcome(outcome.error());
-}
-
-void ImmClient::getFaceSearchImageAsync(const GetFaceSearchImageRequest& request, const GetFaceSearchImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, getFaceSearchImage(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::GetFaceSearchImageOutcomeCallable ImmClient::getFaceSearchImageCallable(const GetFaceSearchImageRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<GetFaceSearchImageOutcome()>>(
-			[this, request]()
-			{
-			return this->getFaceSearchImage(request);
+			return this->createTagJob(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -447,42 +303,6 @@ ImmClient::CompareFaceOutcomeCallable ImmClient::compareFaceCallable(const Compa
 	return task->get_future();
 }
 
-ImmClient::DetectTagOutcome ImmClient::detectTag(const DetectTagRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DetectTagOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DetectTagOutcome(DetectTagResult(outcome.result()));
-	else
-		return DetectTagOutcome(outcome.error());
-}
-
-void ImmClient::detectTagAsync(const DetectTagRequest& request, const DetectTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, detectTag(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DetectTagOutcomeCallable ImmClient::detectTagCallable(const DetectTagRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DetectTagOutcome()>>(
-			[this, request]()
-			{
-			return this->detectTag(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::ListFaceSearchGroupUsersOutcome ImmClient::listFaceSearchGroupUsers(const ListFaceSearchGroupUsersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,150 +375,6 @@ ImmClient::ListFaceSearchGroupImagesOutcomeCallable ImmClient::listFaceSearchGro
 	return task->get_future();
 }
 
-ImmClient::CreateCADConversionTaskOutcome ImmClient::createCADConversionTask(const CreateCADConversionTaskRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateCADConversionTaskOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateCADConversionTaskOutcome(CreateCADConversionTaskResult(outcome.result()));
-	else
-		return CreateCADConversionTaskOutcome(outcome.error());
-}
-
-void ImmClient::createCADConversionTaskAsync(const CreateCADConversionTaskRequest& request, const CreateCADConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createCADConversionTask(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreateCADConversionTaskOutcomeCallable ImmClient::createCADConversionTaskCallable(const CreateCADConversionTaskRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateCADConversionTaskOutcome()>>(
-			[this, request]()
-			{
-			return this->createCADConversionTask(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::GetTagJobOutcome ImmClient::getTagJob(const GetTagJobRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return GetTagJobOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return GetTagJobOutcome(GetTagJobResult(outcome.result()));
-	else
-		return GetTagJobOutcome(outcome.error());
-}
-
-void ImmClient::getTagJobAsync(const GetTagJobRequest& request, const GetTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, getTagJob(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::GetTagJobOutcomeCallable ImmClient::getTagJobCallable(const GetTagJobRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<GetTagJobOutcome()>>(
-			[this, request]()
-			{
-			return this->getTagJob(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::DeleteFaceJobOutcome ImmClient::deleteFaceJob(const DeleteFaceJobRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeleteFaceJobOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeleteFaceJobOutcome(DeleteFaceJobResult(outcome.result()));
-	else
-		return DeleteFaceJobOutcome(outcome.error());
-}
-
-void ImmClient::deleteFaceJobAsync(const DeleteFaceJobRequest& request, const DeleteFaceJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deleteFaceJob(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DeleteFaceJobOutcomeCallable ImmClient::deleteFaceJobCallable(const DeleteFaceJobRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeleteFaceJobOutcome()>>(
-			[this, request]()
-			{
-			return this->deleteFaceJob(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::CreateDocIndexTaskOutcome ImmClient::createDocIndexTask(const CreateDocIndexTaskRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateDocIndexTaskOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateDocIndexTaskOutcome(CreateDocIndexTaskResult(outcome.result()));
-	else
-		return CreateDocIndexTaskOutcome(outcome.error());
-}
-
-void ImmClient::createDocIndexTaskAsync(const CreateDocIndexTaskRequest& request, const CreateDocIndexTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createDocIndexTask(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreateDocIndexTaskOutcomeCallable ImmClient::createDocIndexTaskCallable(const CreateDocIndexTaskRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateDocIndexTaskOutcome()>>(
-			[this, request]()
-			{
-			return this->createDocIndexTask(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::PutProjectOutcome ImmClient::putProject(const PutProjectRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -735,78 +411,6 @@ ImmClient::PutProjectOutcomeCallable ImmClient::putProjectCallable(const PutProj
 	return task->get_future();
 }
 
-ImmClient::GetSetOutcome ImmClient::getSet(const GetSetRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return GetSetOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return GetSetOutcome(GetSetResult(outcome.result()));
-	else
-		return GetSetOutcome(outcome.error());
-}
-
-void ImmClient::getSetAsync(const GetSetRequest& request, const GetSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, getSet(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::GetSetOutcomeCallable ImmClient::getSetCallable(const GetSetRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<GetSetOutcome()>>(
-			[this, request]()
-			{
-			return this->getSet(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::GetVideoTaskOutcome ImmClient::getVideoTask(const GetVideoTaskRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return GetVideoTaskOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return GetVideoTaskOutcome(GetVideoTaskResult(outcome.result()));
-	else
-		return GetVideoTaskOutcome(outcome.error());
-}
-
-void ImmClient::getVideoTaskAsync(const GetVideoTaskRequest& request, const GetVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, getVideoTask(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::GetVideoTaskOutcomeCallable ImmClient::getVideoTaskCallable(const GetVideoTaskRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<GetVideoTaskOutcome()>>(
-			[this, request]()
-			{
-			return this->getVideoTask(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::ListSetsOutcome ImmClient::listSets(const ListSetsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,150 +447,6 @@ ImmClient::ListSetsOutcomeCallable ImmClient::listSetsCallable(const ListSetsReq
 	return task->get_future();
 }
 
-ImmClient::SearchDocIndexOutcome ImmClient::searchDocIndex(const SearchDocIndexRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return SearchDocIndexOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return SearchDocIndexOutcome(SearchDocIndexResult(outcome.result()));
-	else
-		return SearchDocIndexOutcome(outcome.error());
-}
-
-void ImmClient::searchDocIndexAsync(const SearchDocIndexRequest& request, const SearchDocIndexAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, searchDocIndex(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::SearchDocIndexOutcomeCallable ImmClient::searchDocIndexCallable(const SearchDocIndexRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<SearchDocIndexOutcome()>>(
-			[this, request]()
-			{
-			return this->searchDocIndex(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::ListPhotoProcessTasksOutcome ImmClient::listPhotoProcessTasks(const ListPhotoProcessTasksRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListPhotoProcessTasksOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListPhotoProcessTasksOutcome(ListPhotoProcessTasksResult(outcome.result()));
-	else
-		return ListPhotoProcessTasksOutcome(outcome.error());
-}
-
-void ImmClient::listPhotoProcessTasksAsync(const ListPhotoProcessTasksRequest& request, const ListPhotoProcessTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listPhotoProcessTasks(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::ListPhotoProcessTasksOutcomeCallable ImmClient::listPhotoProcessTasksCallable(const ListPhotoProcessTasksRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListPhotoProcessTasksOutcome()>>(
-			[this, request]()
-			{
-			return this->listPhotoProcessTasks(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::ListVideosOutcome ImmClient::listVideos(const ListVideosRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListVideosOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListVideosOutcome(ListVideosResult(outcome.result()));
-	else
-		return ListVideosOutcome(outcome.error());
-}
-
-void ImmClient::listVideosAsync(const ListVideosRequest& request, const ListVideosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listVideos(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::ListVideosOutcomeCallable ImmClient::listVideosCallable(const ListVideosRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListVideosOutcome()>>(
-			[this, request]()
-			{
-			return this->listVideos(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::CreatePornBatchDetectJobOutcome ImmClient::createPornBatchDetectJob(const CreatePornBatchDetectJobRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreatePornBatchDetectJobOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreatePornBatchDetectJobOutcome(CreatePornBatchDetectJobResult(outcome.result()));
-	else
-		return CreatePornBatchDetectJobOutcome(outcome.error());
-}
-
-void ImmClient::createPornBatchDetectJobAsync(const CreatePornBatchDetectJobRequest& request, const CreatePornBatchDetectJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createPornBatchDetectJob(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreatePornBatchDetectJobOutcomeCallable ImmClient::createPornBatchDetectJobCallable(const CreatePornBatchDetectJobRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreatePornBatchDetectJobOutcome()>>(
-			[this, request]()
-			{
-			return this->createPornBatchDetectJob(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::FindImagesOutcome ImmClient::findImages(const FindImagesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1023,42 +483,6 @@ ImmClient::FindImagesOutcomeCallable ImmClient::findImagesCallable(const FindIma
 	return task->get_future();
 }
 
-ImmClient::DeleteTagByNameOutcome ImmClient::deleteTagByName(const DeleteTagByNameRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeleteTagByNameOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeleteTagByNameOutcome(DeleteTagByNameResult(outcome.result()));
-	else
-		return DeleteTagByNameOutcome(outcome.error());
-}
-
-void ImmClient::deleteTagByNameAsync(const DeleteTagByNameRequest& request, const DeleteTagByNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deleteTagByName(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DeleteTagByNameOutcomeCallable ImmClient::deleteTagByNameCallable(const DeleteTagByNameRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeleteTagByNameOutcome()>>(
-			[this, request]()
-			{
-			return this->deleteTagByName(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DetectImageLogosOutcome ImmClient::detectImageLogos(const DetectImageLogosRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1131,150 +555,6 @@ ImmClient::GetProjectOutcomeCallable ImmClient::getProjectCallable(const GetProj
 	return task->get_future();
 }
 
-ImmClient::DeletePhotoProcessTaskOutcome ImmClient::deletePhotoProcessTask(const DeletePhotoProcessTaskRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeletePhotoProcessTaskOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeletePhotoProcessTaskOutcome(DeletePhotoProcessTaskResult(outcome.result()));
-	else
-		return DeletePhotoProcessTaskOutcome(outcome.error());
-}
-
-void ImmClient::deletePhotoProcessTaskAsync(const DeletePhotoProcessTaskRequest& request, const DeletePhotoProcessTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deletePhotoProcessTask(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DeletePhotoProcessTaskOutcomeCallable ImmClient::deletePhotoProcessTaskCallable(const DeletePhotoProcessTaskRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeletePhotoProcessTaskOutcome()>>(
-			[this, request]()
-			{
-			return this->deletePhotoProcessTask(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::ListSetTagsOutcome ImmClient::listSetTags(const ListSetTagsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListSetTagsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListSetTagsOutcome(ListSetTagsResult(outcome.result()));
-	else
-		return ListSetTagsOutcome(outcome.error());
-}
-
-void ImmClient::listSetTagsAsync(const ListSetTagsRequest& request, const ListSetTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listSetTags(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::ListSetTagsOutcomeCallable ImmClient::listSetTagsCallable(const ListSetTagsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListSetTagsOutcome()>>(
-			[this, request]()
-			{
-			return this->listSetTags(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::DeleteVideoTaskOutcome ImmClient::deleteVideoTask(const DeleteVideoTaskRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeleteVideoTaskOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeleteVideoTaskOutcome(DeleteVideoTaskResult(outcome.result()));
-	else
-		return DeleteVideoTaskOutcome(outcome.error());
-}
-
-void ImmClient::deleteVideoTaskAsync(const DeleteVideoTaskRequest& request, const DeleteVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deleteVideoTask(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DeleteVideoTaskOutcomeCallable ImmClient::deleteVideoTaskCallable(const DeleteVideoTaskRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeleteVideoTaskOutcome()>>(
-			[this, request]()
-			{
-			return this->deleteVideoTask(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::FindImagesByTagNamesOutcome ImmClient::findImagesByTagNames(const FindImagesByTagNamesRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return FindImagesByTagNamesOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return FindImagesByTagNamesOutcome(FindImagesByTagNamesResult(outcome.result()));
-	else
-		return FindImagesByTagNamesOutcome(outcome.error());
-}
-
-void ImmClient::findImagesByTagNamesAsync(const FindImagesByTagNamesRequest& request, const FindImagesByTagNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, findImagesByTagNames(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::FindImagesByTagNamesOutcomeCallable ImmClient::findImagesByTagNamesCallable(const FindImagesByTagNamesRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<FindImagesByTagNamesOutcome()>>(
-			[this, request]()
-			{
-			return this->findImagesByTagNames(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DeleteTagSetOutcome ImmClient::deleteTagSet(const DeleteTagSetRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1419,42 +699,6 @@ ImmClient::SearchFaceOutcomeCallable ImmClient::searchFaceCallable(const SearchF
 	return task->get_future();
 }
 
-ImmClient::GetImageOutcome ImmClient::getImage(const GetImageRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return GetImageOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return GetImageOutcome(GetImageResult(outcome.result()));
-	else
-		return GetImageOutcome(outcome.error());
-}
-
-void ImmClient::getImageAsync(const GetImageRequest& request, const GetImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, getImage(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::GetImageOutcomeCallable ImmClient::getImageCallable(const GetImageRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<GetImageOutcome()>>(
-			[this, request]()
-			{
-			return this->getImage(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DetectImageCelebrityOutcome ImmClient::detectImageCelebrity(const DetectImageCelebrityRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1491,78 +735,6 @@ ImmClient::DetectImageCelebrityOutcomeCallable ImmClient::detectImageCelebrityCa
 	return task->get_future();
 }
 
-ImmClient::CreateSetOutcome ImmClient::createSet(const CreateSetRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateSetOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateSetOutcome(CreateSetResult(outcome.result()));
-	else
-		return CreateSetOutcome(outcome.error());
-}
-
-void ImmClient::createSetAsync(const CreateSetRequest& request, const CreateSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createSet(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreateSetOutcomeCallable ImmClient::createSetCallable(const CreateSetRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateSetOutcome()>>(
-			[this, request]()
-			{
-			return this->createSet(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::DeletePornBatchDetectJobOutcome ImmClient::deletePornBatchDetectJob(const DeletePornBatchDetectJobRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeletePornBatchDetectJobOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeletePornBatchDetectJobOutcome(DeletePornBatchDetectJobResult(outcome.result()));
-	else
-		return DeletePornBatchDetectJobOutcome(outcome.error());
-}
-
-void ImmClient::deletePornBatchDetectJobAsync(const DeletePornBatchDetectJobRequest& request, const DeletePornBatchDetectJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deletePornBatchDetectJob(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DeletePornBatchDetectJobOutcomeCallable ImmClient::deletePornBatchDetectJobCallable(const DeletePornBatchDetectJobRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeletePornBatchDetectJobOutcome()>>(
-			[this, request]()
-			{
-			return this->deletePornBatchDetectJob(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::ListFaceSearchGroupsOutcome ImmClient::listFaceSearchGroups(const ListFaceSearchGroupsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1635,72 +807,36 @@ ImmClient::GetTagSetOutcomeCallable ImmClient::getTagSetCallable(const GetTagSet
 	return task->get_future();
 }
 
-ImmClient::ConvertOfficeFormatOutcome ImmClient::convertOfficeFormat(const ConvertOfficeFormatRequest &request) const
+ImmClient::DeletePornBatchDetectJobOutcome ImmClient::deletePornBatchDetectJob(const DeletePornBatchDetectJobRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return ConvertOfficeFormatOutcome(endpointOutcome.error());
+		return DeletePornBatchDetectJobOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return ConvertOfficeFormatOutcome(ConvertOfficeFormatResult(outcome.result()));
+		return DeletePornBatchDetectJobOutcome(DeletePornBatchDetectJobResult(outcome.result()));
 	else
-		return ConvertOfficeFormatOutcome(outcome.error());
+		return DeletePornBatchDetectJobOutcome(outcome.error());
 }
 
-void ImmClient::convertOfficeFormatAsync(const ConvertOfficeFormatRequest& request, const ConvertOfficeFormatAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void ImmClient::deletePornBatchDetectJobAsync(const DeletePornBatchDetectJobRequest& request, const DeletePornBatchDetectJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, convertOfficeFormat(request), context);
+		handler(this, request, deletePornBatchDetectJob(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-ImmClient::ConvertOfficeFormatOutcomeCallable ImmClient::convertOfficeFormatCallable(const ConvertOfficeFormatRequest &request) const
+ImmClient::DeletePornBatchDetectJobOutcomeCallable ImmClient::deletePornBatchDetectJobCallable(const DeletePornBatchDetectJobRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<ConvertOfficeFormatOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DeletePornBatchDetectJobOutcome()>>(
 			[this, request]()
 			{
-			return this->convertOfficeFormat(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::UpdateFaceGroupOutcome ImmClient::updateFaceGroup(const UpdateFaceGroupRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return UpdateFaceGroupOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return UpdateFaceGroupOutcome(UpdateFaceGroupResult(outcome.result()));
-	else
-		return UpdateFaceGroupOutcome(outcome.error());
-}
-
-void ImmClient::updateFaceGroupAsync(const UpdateFaceGroupRequest& request, const UpdateFaceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, updateFaceGroup(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::UpdateFaceGroupOutcomeCallable ImmClient::updateFaceGroupCallable(const UpdateFaceGroupRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<UpdateFaceGroupOutcome()>>(
-			[this, request]()
-			{
-			return this->updateFaceGroup(request);
+			return this->deletePornBatchDetectJob(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -1743,42 +879,6 @@ ImmClient::ListTagPhotosOutcomeCallable ImmClient::listTagPhotosCallable(const L
 	return task->get_future();
 }
 
-ImmClient::DetectImageBodiesOutcome ImmClient::detectImageBodies(const DetectImageBodiesRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DetectImageBodiesOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DetectImageBodiesOutcome(DetectImageBodiesResult(outcome.result()));
-	else
-		return DetectImageBodiesOutcome(outcome.error());
-}
-
-void ImmClient::detectImageBodiesAsync(const DetectImageBodiesRequest& request, const DetectImageBodiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, detectImageBodies(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DetectImageBodiesOutcomeCallable ImmClient::detectImageBodiesCallable(const DetectImageBodiesRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DetectImageBodiesOutcome()>>(
-			[this, request]()
-			{
-			return this->detectImageBodies(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DeleteFaceSearchImageByIdOutcome ImmClient::deleteFaceSearchImageById(const DeleteFaceSearchImageByIdRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1851,6 +951,1662 @@ ImmClient::IndexVideoOutcomeCallable ImmClient::indexVideoCallable(const IndexVi
 	return task->get_future();
 }
 
+ImmClient::ListVideoAudiosOutcome ImmClient::listVideoAudios(const ListVideoAudiosRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVideoAudiosOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVideoAudiosOutcome(ListVideoAudiosResult(outcome.result()));
+	else
+		return ListVideoAudiosOutcome(outcome.error());
+}
+
+void ImmClient::listVideoAudiosAsync(const ListVideoAudiosRequest& request, const ListVideoAudiosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVideoAudios(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ListVideoAudiosOutcomeCallable ImmClient::listVideoAudiosCallable(const ListVideoAudiosRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVideoAudiosOutcome()>>(
+			[this, request]()
+			{
+			return this->listVideoAudios(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CreateMergeFaceGroupsJobOutcome ImmClient::createMergeFaceGroupsJob(const CreateMergeFaceGroupsJobRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateMergeFaceGroupsJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateMergeFaceGroupsJobOutcome(CreateMergeFaceGroupsJobResult(outcome.result()));
+	else
+		return CreateMergeFaceGroupsJobOutcome(outcome.error());
+}
+
+void ImmClient::createMergeFaceGroupsJobAsync(const CreateMergeFaceGroupsJobRequest& request, const CreateMergeFaceGroupsJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createMergeFaceGroupsJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CreateMergeFaceGroupsJobOutcomeCallable ImmClient::createMergeFaceGroupsJobCallable(const CreateMergeFaceGroupsJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateMergeFaceGroupsJobOutcome()>>(
+			[this, request]()
+			{
+			return this->createMergeFaceGroupsJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::ListTagNamesOutcome ImmClient::listTagNames(const ListTagNamesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTagNamesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTagNamesOutcome(ListTagNamesResult(outcome.result()));
+	else
+		return ListTagNamesOutcome(outcome.error());
+}
+
+void ImmClient::listTagNamesAsync(const ListTagNamesRequest& request, const ListTagNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTagNames(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ListTagNamesOutcomeCallable ImmClient::listTagNamesCallable(const ListTagNamesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTagNamesOutcome()>>(
+			[this, request]()
+			{
+			return this->listTagNames(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CreateOfficeConversionTaskOutcome ImmClient::createOfficeConversionTask(const CreateOfficeConversionTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateOfficeConversionTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateOfficeConversionTaskOutcome(CreateOfficeConversionTaskResult(outcome.result()));
+	else
+		return CreateOfficeConversionTaskOutcome(outcome.error());
+}
+
+void ImmClient::createOfficeConversionTaskAsync(const CreateOfficeConversionTaskRequest& request, const CreateOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createOfficeConversionTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CreateOfficeConversionTaskOutcomeCallable ImmClient::createOfficeConversionTaskCallable(const CreateOfficeConversionTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateOfficeConversionTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->createOfficeConversionTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::GetFaceSearchGroupOutcome ImmClient::getFaceSearchGroup(const GetFaceSearchGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetFaceSearchGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetFaceSearchGroupOutcome(GetFaceSearchGroupResult(outcome.result()));
+	else
+		return GetFaceSearchGroupOutcome(outcome.error());
+}
+
+void ImmClient::getFaceSearchGroupAsync(const GetFaceSearchGroupRequest& request, const GetFaceSearchGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getFaceSearchGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::GetFaceSearchGroupOutcomeCallable ImmClient::getFaceSearchGroupCallable(const GetFaceSearchGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetFaceSearchGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->getFaceSearchGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CompareImageFacesOutcome ImmClient::compareImageFaces(const CompareImageFacesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CompareImageFacesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CompareImageFacesOutcome(CompareImageFacesResult(outcome.result()));
+	else
+		return CompareImageFacesOutcome(outcome.error());
+}
+
+void ImmClient::compareImageFacesAsync(const CompareImageFacesRequest& request, const CompareImageFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, compareImageFaces(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CompareImageFacesOutcomeCallable ImmClient::compareImageFacesCallable(const CompareImageFacesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CompareImageFacesOutcome()>>(
+			[this, request]()
+			{
+			return this->compareImageFaces(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DeleteTagJobOutcome ImmClient::deleteTagJob(const DeleteTagJobRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteTagJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteTagJobOutcome(DeleteTagJobResult(outcome.result()));
+	else
+		return DeleteTagJobOutcome(outcome.error());
+}
+
+void ImmClient::deleteTagJobAsync(const DeleteTagJobRequest& request, const DeleteTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteTagJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DeleteTagJobOutcomeCallable ImmClient::deleteTagJobCallable(const DeleteTagJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteTagJobOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteTagJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::PhotoProcessOutcome ImmClient::photoProcess(const PhotoProcessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PhotoProcessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PhotoProcessOutcome(PhotoProcessResult(outcome.result()));
+	else
+		return PhotoProcessOutcome(outcome.error());
+}
+
+void ImmClient::photoProcessAsync(const PhotoProcessRequest& request, const PhotoProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, photoProcess(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::PhotoProcessOutcomeCallable ImmClient::photoProcessCallable(const PhotoProcessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PhotoProcessOutcome()>>(
+			[this, request]()
+			{
+			return this->photoProcess(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DeleteFaceSearchUserOutcome ImmClient::deleteFaceSearchUser(const DeleteFaceSearchUserRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFaceSearchUserOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFaceSearchUserOutcome(DeleteFaceSearchUserResult(outcome.result()));
+	else
+		return DeleteFaceSearchUserOutcome(outcome.error());
+}
+
+void ImmClient::deleteFaceSearchUserAsync(const DeleteFaceSearchUserRequest& request, const DeleteFaceSearchUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFaceSearchUser(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DeleteFaceSearchUserOutcomeCallable ImmClient::deleteFaceSearchUserCallable(const DeleteFaceSearchUserRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFaceSearchUserOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFaceSearchUser(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::GetOfficeConversionTaskOutcome ImmClient::getOfficeConversionTask(const GetOfficeConversionTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetOfficeConversionTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetOfficeConversionTaskOutcome(GetOfficeConversionTaskResult(outcome.result()));
+	else
+		return GetOfficeConversionTaskOutcome(outcome.error());
+}
+
+void ImmClient::getOfficeConversionTaskAsync(const GetOfficeConversionTaskRequest& request, const GetOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getOfficeConversionTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::GetOfficeConversionTaskOutcomeCallable ImmClient::getOfficeConversionTaskCallable(const GetOfficeConversionTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetOfficeConversionTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->getOfficeConversionTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::RegistFaceOutcome ImmClient::registFace(const RegistFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RegistFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RegistFaceOutcome(RegistFaceResult(outcome.result()));
+	else
+		return RegistFaceOutcome(outcome.error());
+}
+
+void ImmClient::registFaceAsync(const RegistFaceRequest& request, const RegistFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, registFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::RegistFaceOutcomeCallable ImmClient::registFaceCallable(const RegistFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RegistFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->registFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CreateTagSetOutcome ImmClient::createTagSet(const CreateTagSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateTagSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateTagSetOutcome(CreateTagSetResult(outcome.result()));
+	else
+		return CreateTagSetOutcome(outcome.error());
+}
+
+void ImmClient::createTagSetAsync(const CreateTagSetRequest& request, const CreateTagSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createTagSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CreateTagSetOutcomeCallable ImmClient::createTagSetCallable(const CreateTagSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateTagSetOutcome()>>(
+			[this, request]()
+			{
+			return this->createTagSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::GetFaceSearchUserOutcome ImmClient::getFaceSearchUser(const GetFaceSearchUserRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetFaceSearchUserOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetFaceSearchUserOutcome(GetFaceSearchUserResult(outcome.result()));
+	else
+		return GetFaceSearchUserOutcome(outcome.error());
+}
+
+void ImmClient::getFaceSearchUserAsync(const GetFaceSearchUserRequest& request, const GetFaceSearchUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getFaceSearchUser(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::GetFaceSearchUserOutcomeCallable ImmClient::getFaceSearchUserCallable(const GetFaceSearchUserRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetFaceSearchUserOutcome()>>(
+			[this, request]()
+			{
+			return this->getFaceSearchUser(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CreateFaceSetOutcome ImmClient::createFaceSet(const CreateFaceSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateFaceSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateFaceSetOutcome(CreateFaceSetResult(outcome.result()));
+	else
+		return CreateFaceSetOutcome(outcome.error());
+}
+
+void ImmClient::createFaceSetAsync(const CreateFaceSetRequest& request, const CreateFaceSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createFaceSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CreateFaceSetOutcomeCallable ImmClient::createFaceSetCallable(const CreateFaceSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateFaceSetOutcome()>>(
+			[this, request]()
+			{
+			return this->createFaceSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::ListProjectAPIsOutcome ImmClient::listProjectAPIs(const ListProjectAPIsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListProjectAPIsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListProjectAPIsOutcome(ListProjectAPIsResult(outcome.result()));
+	else
+		return ListProjectAPIsOutcome(outcome.error());
+}
+
+void ImmClient::listProjectAPIsAsync(const ListProjectAPIsRequest& request, const ListProjectAPIsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listProjectAPIs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ListProjectAPIsOutcomeCallable ImmClient::listProjectAPIsCallable(const ListProjectAPIsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListProjectAPIsOutcome()>>(
+			[this, request]()
+			{
+			return this->listProjectAPIs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DetectImageTextsOutcome ImmClient::detectImageTexts(const DetectImageTextsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectImageTextsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectImageTextsOutcome(DetectImageTextsResult(outcome.result()));
+	else
+		return DetectImageTextsOutcome(outcome.error());
+}
+
+void ImmClient::detectImageTextsAsync(const DetectImageTextsRequest& request, const DetectImageTextsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectImageTexts(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DetectImageTextsOutcomeCallable ImmClient::detectImageTextsCallable(const DetectImageTextsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectImageTextsOutcome()>>(
+			[this, request]()
+			{
+			return this->detectImageTexts(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CreateGroupFacesJobOutcome ImmClient::createGroupFacesJob(const CreateGroupFacesJobRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateGroupFacesJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateGroupFacesJobOutcome(CreateGroupFacesJobResult(outcome.result()));
+	else
+		return CreateGroupFacesJobOutcome(outcome.error());
+}
+
+void ImmClient::createGroupFacesJobAsync(const CreateGroupFacesJobRequest& request, const CreateGroupFacesJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createGroupFacesJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CreateGroupFacesJobOutcomeCallable ImmClient::createGroupFacesJobCallable(const CreateGroupFacesJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateGroupFacesJobOutcome()>>(
+			[this, request]()
+			{
+			return this->createGroupFacesJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DeleteVideoOutcome ImmClient::deleteVideo(const DeleteVideoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteVideoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteVideoOutcome(DeleteVideoResult(outcome.result()));
+	else
+		return DeleteVideoOutcome(outcome.error());
+}
+
+void ImmClient::deleteVideoAsync(const DeleteVideoRequest& request, const DeleteVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteVideo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DeleteVideoOutcomeCallable ImmClient::deleteVideoCallable(const DeleteVideoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteVideoOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteVideo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::ListOfficeConversionTaskOutcome ImmClient::listOfficeConversionTask(const ListOfficeConversionTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListOfficeConversionTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListOfficeConversionTaskOutcome(ListOfficeConversionTaskResult(outcome.result()));
+	else
+		return ListOfficeConversionTaskOutcome(outcome.error());
+}
+
+void ImmClient::listOfficeConversionTaskAsync(const ListOfficeConversionTaskRequest& request, const ListOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listOfficeConversionTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ListOfficeConversionTaskOutcomeCallable ImmClient::listOfficeConversionTaskCallable(const ListOfficeConversionTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListOfficeConversionTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->listOfficeConversionTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::ListFaceGroupsOutcome ImmClient::listFaceGroups(const ListFaceGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListFaceGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListFaceGroupsOutcome(ListFaceGroupsResult(outcome.result()));
+	else
+		return ListFaceGroupsOutcome(outcome.error());
+}
+
+void ImmClient::listFaceGroupsAsync(const ListFaceGroupsRequest& request, const ListFaceGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listFaceGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ListFaceGroupsOutcomeCallable ImmClient::listFaceGroupsCallable(const ListFaceGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListFaceGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->listFaceGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DetectImageTagsOutcome ImmClient::detectImageTags(const DetectImageTagsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectImageTagsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectImageTagsOutcome(DetectImageTagsResult(outcome.result()));
+	else
+		return DetectImageTagsOutcome(outcome.error());
+}
+
+void ImmClient::detectImageTagsAsync(const DetectImageTagsRequest& request, const DetectImageTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectImageTags(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DetectImageTagsOutcomeCallable ImmClient::detectImageTagsCallable(const DetectImageTagsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectImageTagsOutcome()>>(
+			[this, request]()
+			{
+			return this->detectImageTags(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::ListProjectsOutcome ImmClient::listProjects(const ListProjectsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListProjectsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListProjectsOutcome(ListProjectsResult(outcome.result()));
+	else
+		return ListProjectsOutcome(outcome.error());
+}
+
+void ImmClient::listProjectsAsync(const ListProjectsRequest& request, const ListProjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listProjects(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ListProjectsOutcomeCallable ImmClient::listProjectsCallable(const ListProjectsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListProjectsOutcome()>>(
+			[this, request]()
+			{
+			return this->listProjects(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DeleteSetOutcome ImmClient::deleteSet(const DeleteSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteSetOutcome(DeleteSetResult(outcome.result()));
+	else
+		return DeleteSetOutcome(outcome.error());
+}
+
+void ImmClient::deleteSetAsync(const DeleteSetRequest& request, const DeleteSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DeleteSetOutcomeCallable ImmClient::deleteSetCallable(const DeleteSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteSetOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::GetFaceSearchImageOutcome ImmClient::getFaceSearchImage(const GetFaceSearchImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetFaceSearchImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetFaceSearchImageOutcome(GetFaceSearchImageResult(outcome.result()));
+	else
+		return GetFaceSearchImageOutcome(outcome.error());
+}
+
+void ImmClient::getFaceSearchImageAsync(const GetFaceSearchImageRequest& request, const GetFaceSearchImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getFaceSearchImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::GetFaceSearchImageOutcomeCallable ImmClient::getFaceSearchImageCallable(const GetFaceSearchImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetFaceSearchImageOutcome()>>(
+			[this, request]()
+			{
+			return this->getFaceSearchImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DetectTagOutcome ImmClient::detectTag(const DetectTagRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectTagOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectTagOutcome(DetectTagResult(outcome.result()));
+	else
+		return DetectTagOutcome(outcome.error());
+}
+
+void ImmClient::detectTagAsync(const DetectTagRequest& request, const DetectTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectTag(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DetectTagOutcomeCallable ImmClient::detectTagCallable(const DetectTagRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectTagOutcome()>>(
+			[this, request]()
+			{
+			return this->detectTag(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CreateCADConversionTaskOutcome ImmClient::createCADConversionTask(const CreateCADConversionTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateCADConversionTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateCADConversionTaskOutcome(CreateCADConversionTaskResult(outcome.result()));
+	else
+		return CreateCADConversionTaskOutcome(outcome.error());
+}
+
+void ImmClient::createCADConversionTaskAsync(const CreateCADConversionTaskRequest& request, const CreateCADConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createCADConversionTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CreateCADConversionTaskOutcomeCallable ImmClient::createCADConversionTaskCallable(const CreateCADConversionTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateCADConversionTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->createCADConversionTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::GetTagJobOutcome ImmClient::getTagJob(const GetTagJobRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTagJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTagJobOutcome(GetTagJobResult(outcome.result()));
+	else
+		return GetTagJobOutcome(outcome.error());
+}
+
+void ImmClient::getTagJobAsync(const GetTagJobRequest& request, const GetTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTagJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::GetTagJobOutcomeCallable ImmClient::getTagJobCallable(const GetTagJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTagJobOutcome()>>(
+			[this, request]()
+			{
+			return this->getTagJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DeleteFaceJobOutcome ImmClient::deleteFaceJob(const DeleteFaceJobRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFaceJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFaceJobOutcome(DeleteFaceJobResult(outcome.result()));
+	else
+		return DeleteFaceJobOutcome(outcome.error());
+}
+
+void ImmClient::deleteFaceJobAsync(const DeleteFaceJobRequest& request, const DeleteFaceJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFaceJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DeleteFaceJobOutcomeCallable ImmClient::deleteFaceJobCallable(const DeleteFaceJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFaceJobOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFaceJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CreateDocIndexTaskOutcome ImmClient::createDocIndexTask(const CreateDocIndexTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDocIndexTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDocIndexTaskOutcome(CreateDocIndexTaskResult(outcome.result()));
+	else
+		return CreateDocIndexTaskOutcome(outcome.error());
+}
+
+void ImmClient::createDocIndexTaskAsync(const CreateDocIndexTaskRequest& request, const CreateDocIndexTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDocIndexTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CreateDocIndexTaskOutcomeCallable ImmClient::createDocIndexTaskCallable(const CreateDocIndexTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDocIndexTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->createDocIndexTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::GetVideoTaskOutcome ImmClient::getVideoTask(const GetVideoTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetVideoTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetVideoTaskOutcome(GetVideoTaskResult(outcome.result()));
+	else
+		return GetVideoTaskOutcome(outcome.error());
+}
+
+void ImmClient::getVideoTaskAsync(const GetVideoTaskRequest& request, const GetVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getVideoTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::GetVideoTaskOutcomeCallable ImmClient::getVideoTaskCallable(const GetVideoTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetVideoTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->getVideoTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::GetSetOutcome ImmClient::getSet(const GetSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetSetOutcome(GetSetResult(outcome.result()));
+	else
+		return GetSetOutcome(outcome.error());
+}
+
+void ImmClient::getSetAsync(const GetSetRequest& request, const GetSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::GetSetOutcomeCallable ImmClient::getSetCallable(const GetSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetSetOutcome()>>(
+			[this, request]()
+			{
+			return this->getSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::SearchDocIndexOutcome ImmClient::searchDocIndex(const SearchDocIndexRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SearchDocIndexOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SearchDocIndexOutcome(SearchDocIndexResult(outcome.result()));
+	else
+		return SearchDocIndexOutcome(outcome.error());
+}
+
+void ImmClient::searchDocIndexAsync(const SearchDocIndexRequest& request, const SearchDocIndexAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, searchDocIndex(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::SearchDocIndexOutcomeCallable ImmClient::searchDocIndexCallable(const SearchDocIndexRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SearchDocIndexOutcome()>>(
+			[this, request]()
+			{
+			return this->searchDocIndex(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::ListPhotoProcessTasksOutcome ImmClient::listPhotoProcessTasks(const ListPhotoProcessTasksRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListPhotoProcessTasksOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListPhotoProcessTasksOutcome(ListPhotoProcessTasksResult(outcome.result()));
+	else
+		return ListPhotoProcessTasksOutcome(outcome.error());
+}
+
+void ImmClient::listPhotoProcessTasksAsync(const ListPhotoProcessTasksRequest& request, const ListPhotoProcessTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listPhotoProcessTasks(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ListPhotoProcessTasksOutcomeCallable ImmClient::listPhotoProcessTasksCallable(const ListPhotoProcessTasksRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListPhotoProcessTasksOutcome()>>(
+			[this, request]()
+			{
+			return this->listPhotoProcessTasks(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::ListVideosOutcome ImmClient::listVideos(const ListVideosRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVideosOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVideosOutcome(ListVideosResult(outcome.result()));
+	else
+		return ListVideosOutcome(outcome.error());
+}
+
+void ImmClient::listVideosAsync(const ListVideosRequest& request, const ListVideosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVideos(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ListVideosOutcomeCallable ImmClient::listVideosCallable(const ListVideosRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVideosOutcome()>>(
+			[this, request]()
+			{
+			return this->listVideos(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CreatePornBatchDetectJobOutcome ImmClient::createPornBatchDetectJob(const CreatePornBatchDetectJobRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreatePornBatchDetectJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreatePornBatchDetectJobOutcome(CreatePornBatchDetectJobResult(outcome.result()));
+	else
+		return CreatePornBatchDetectJobOutcome(outcome.error());
+}
+
+void ImmClient::createPornBatchDetectJobAsync(const CreatePornBatchDetectJobRequest& request, const CreatePornBatchDetectJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createPornBatchDetectJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CreatePornBatchDetectJobOutcomeCallable ImmClient::createPornBatchDetectJobCallable(const CreatePornBatchDetectJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreatePornBatchDetectJobOutcome()>>(
+			[this, request]()
+			{
+			return this->createPornBatchDetectJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DeleteTagByNameOutcome ImmClient::deleteTagByName(const DeleteTagByNameRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteTagByNameOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteTagByNameOutcome(DeleteTagByNameResult(outcome.result()));
+	else
+		return DeleteTagByNameOutcome(outcome.error());
+}
+
+void ImmClient::deleteTagByNameAsync(const DeleteTagByNameRequest& request, const DeleteTagByNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteTagByName(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DeleteTagByNameOutcomeCallable ImmClient::deleteTagByNameCallable(const DeleteTagByNameRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteTagByNameOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteTagByName(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DeletePhotoProcessTaskOutcome ImmClient::deletePhotoProcessTask(const DeletePhotoProcessTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeletePhotoProcessTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeletePhotoProcessTaskOutcome(DeletePhotoProcessTaskResult(outcome.result()));
+	else
+		return DeletePhotoProcessTaskOutcome(outcome.error());
+}
+
+void ImmClient::deletePhotoProcessTaskAsync(const DeletePhotoProcessTaskRequest& request, const DeletePhotoProcessTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deletePhotoProcessTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DeletePhotoProcessTaskOutcomeCallable ImmClient::deletePhotoProcessTaskCallable(const DeletePhotoProcessTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeletePhotoProcessTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->deletePhotoProcessTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::ListSetTagsOutcome ImmClient::listSetTags(const ListSetTagsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSetTagsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSetTagsOutcome(ListSetTagsResult(outcome.result()));
+	else
+		return ListSetTagsOutcome(outcome.error());
+}
+
+void ImmClient::listSetTagsAsync(const ListSetTagsRequest& request, const ListSetTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSetTags(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ListSetTagsOutcomeCallable ImmClient::listSetTagsCallable(const ListSetTagsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSetTagsOutcome()>>(
+			[this, request]()
+			{
+			return this->listSetTags(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DeleteVideoTaskOutcome ImmClient::deleteVideoTask(const DeleteVideoTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteVideoTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteVideoTaskOutcome(DeleteVideoTaskResult(outcome.result()));
+	else
+		return DeleteVideoTaskOutcome(outcome.error());
+}
+
+void ImmClient::deleteVideoTaskAsync(const DeleteVideoTaskRequest& request, const DeleteVideoTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteVideoTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DeleteVideoTaskOutcomeCallable ImmClient::deleteVideoTaskCallable(const DeleteVideoTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteVideoTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteVideoTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::FindImagesByTagNamesOutcome ImmClient::findImagesByTagNames(const FindImagesByTagNamesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FindImagesByTagNamesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FindImagesByTagNamesOutcome(FindImagesByTagNamesResult(outcome.result()));
+	else
+		return FindImagesByTagNamesOutcome(outcome.error());
+}
+
+void ImmClient::findImagesByTagNamesAsync(const FindImagesByTagNamesRequest& request, const FindImagesByTagNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, findImagesByTagNames(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::FindImagesByTagNamesOutcomeCallable ImmClient::findImagesByTagNamesCallable(const FindImagesByTagNamesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FindImagesByTagNamesOutcome()>>(
+			[this, request]()
+			{
+			return this->findImagesByTagNames(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::GetImageOutcome ImmClient::getImage(const GetImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetImageOutcome(GetImageResult(outcome.result()));
+	else
+		return GetImageOutcome(outcome.error());
+}
+
+void ImmClient::getImageAsync(const GetImageRequest& request, const GetImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::GetImageOutcomeCallable ImmClient::getImageCallable(const GetImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetImageOutcome()>>(
+			[this, request]()
+			{
+			return this->getImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::GetMediaMetaOutcome ImmClient::getMediaMeta(const GetMediaMetaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetMediaMetaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetMediaMetaOutcome(GetMediaMetaResult(outcome.result()));
+	else
+		return GetMediaMetaOutcome(outcome.error());
+}
+
+void ImmClient::getMediaMetaAsync(const GetMediaMetaRequest& request, const GetMediaMetaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getMediaMeta(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::GetMediaMetaOutcomeCallable ImmClient::getMediaMetaCallable(const GetMediaMetaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetMediaMetaOutcome()>>(
+			[this, request]()
+			{
+			return this->getMediaMeta(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::CreateSetOutcome ImmClient::createSet(const CreateSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateSetOutcome(CreateSetResult(outcome.result()));
+	else
+		return CreateSetOutcome(outcome.error());
+}
+
+void ImmClient::createSetAsync(const CreateSetRequest& request, const CreateSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::CreateSetOutcomeCallable ImmClient::createSetCallable(const CreateSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateSetOutcome()>>(
+			[this, request]()
+			{
+			return this->createSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::ConvertOfficeFormatOutcome ImmClient::convertOfficeFormat(const ConvertOfficeFormatRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ConvertOfficeFormatOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ConvertOfficeFormatOutcome(ConvertOfficeFormatResult(outcome.result()));
+	else
+		return ConvertOfficeFormatOutcome(outcome.error());
+}
+
+void ImmClient::convertOfficeFormatAsync(const ConvertOfficeFormatRequest& request, const ConvertOfficeFormatAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, convertOfficeFormat(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::ConvertOfficeFormatOutcomeCallable ImmClient::convertOfficeFormatCallable(const ConvertOfficeFormatRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ConvertOfficeFormatOutcome()>>(
+			[this, request]()
+			{
+			return this->convertOfficeFormat(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::UpdateFaceGroupOutcome ImmClient::updateFaceGroup(const UpdateFaceGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateFaceGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateFaceGroupOutcome(UpdateFaceGroupResult(outcome.result()));
+	else
+		return UpdateFaceGroupOutcome(outcome.error());
+}
+
+void ImmClient::updateFaceGroupAsync(const UpdateFaceGroupRequest& request, const UpdateFaceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateFaceGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::UpdateFaceGroupOutcomeCallable ImmClient::updateFaceGroupCallable(const UpdateFaceGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateFaceGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->updateFaceGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImmClient::DetectImageBodiesOutcome ImmClient::detectImageBodies(const DetectImageBodiesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectImageBodiesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectImageBodiesOutcome(DetectImageBodiesResult(outcome.result()));
+	else
+		return DetectImageBodiesOutcome(outcome.error());
+}
+
+void ImmClient::detectImageBodiesAsync(const DetectImageBodiesRequest& request, const DetectImageBodiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectImageBodies(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImmClient::DetectImageBodiesOutcomeCallable ImmClient::detectImageBodiesCallable(const DetectImageBodiesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectImageBodiesOutcome()>>(
+			[this, request]()
+			{
+			return this->detectImageBodies(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ImmClient::DeleteDocIndexOutcome ImmClient::deleteDocIndex(const DeleteDocIndexRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1959,78 +2715,6 @@ ImmClient::GetImageJobOutcomeCallable ImmClient::getImageJobCallable(const GetIm
 	return task->get_future();
 }
 
-ImmClient::ListVideoAudiosOutcome ImmClient::listVideoAudios(const ListVideoAudiosRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListVideoAudiosOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListVideoAudiosOutcome(ListVideoAudiosResult(outcome.result()));
-	else
-		return ListVideoAudiosOutcome(outcome.error());
-}
-
-void ImmClient::listVideoAudiosAsync(const ListVideoAudiosRequest& request, const ListVideoAudiosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listVideoAudios(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::ListVideoAudiosOutcomeCallable ImmClient::listVideoAudiosCallable(const ListVideoAudiosRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListVideoAudiosOutcome()>>(
-			[this, request]()
-			{
-			return this->listVideoAudios(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::CreateMergeFaceGroupsJobOutcome ImmClient::createMergeFaceGroupsJob(const CreateMergeFaceGroupsJobRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateMergeFaceGroupsJobOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateMergeFaceGroupsJobOutcome(CreateMergeFaceGroupsJobResult(outcome.result()));
-	else
-		return CreateMergeFaceGroupsJobOutcome(outcome.error());
-}
-
-void ImmClient::createMergeFaceGroupsJobAsync(const CreateMergeFaceGroupsJobRequest& request, const CreateMergeFaceGroupsJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createMergeFaceGroupsJob(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreateMergeFaceGroupsJobOutcomeCallable ImmClient::createMergeFaceGroupsJobCallable(const CreateMergeFaceGroupsJobRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateMergeFaceGroupsJobOutcome()>>(
-			[this, request]()
-			{
-			return this->createMergeFaceGroupsJob(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DeleteTagByUrlOutcome ImmClient::deleteTagByUrl(const DeleteTagByUrlRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2103,78 +2787,6 @@ ImmClient::ListTagSetsOutcomeCallable ImmClient::listTagSetsCallable(const ListT
 	return task->get_future();
 }
 
-ImmClient::ListTagNamesOutcome ImmClient::listTagNames(const ListTagNamesRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListTagNamesOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListTagNamesOutcome(ListTagNamesResult(outcome.result()));
-	else
-		return ListTagNamesOutcome(outcome.error());
-}
-
-void ImmClient::listTagNamesAsync(const ListTagNamesRequest& request, const ListTagNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listTagNames(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::ListTagNamesOutcomeCallable ImmClient::listTagNamesCallable(const ListTagNamesRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListTagNamesOutcome()>>(
-			[this, request]()
-			{
-			return this->listTagNames(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::CreateOfficeConversionTaskOutcome ImmClient::createOfficeConversionTask(const CreateOfficeConversionTaskRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateOfficeConversionTaskOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateOfficeConversionTaskOutcome(CreateOfficeConversionTaskResult(outcome.result()));
-	else
-		return CreateOfficeConversionTaskOutcome(outcome.error());
-}
-
-void ImmClient::createOfficeConversionTaskAsync(const CreateOfficeConversionTaskRequest& request, const CreateOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createOfficeConversionTask(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreateOfficeConversionTaskOutcomeCallable ImmClient::createOfficeConversionTaskCallable(const CreateOfficeConversionTaskRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateOfficeConversionTaskOutcome()>>(
-			[this, request]()
-			{
-			return this->createOfficeConversionTask(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DetectQRCodesOutcome ImmClient::detectQRCodes(const DetectQRCodesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2211,42 +2823,6 @@ ImmClient::DetectQRCodesOutcomeCallable ImmClient::detectQRCodesCallable(const D
 	return task->get_future();
 }
 
-ImmClient::GetFaceSearchGroupOutcome ImmClient::getFaceSearchGroup(const GetFaceSearchGroupRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return GetFaceSearchGroupOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return GetFaceSearchGroupOutcome(GetFaceSearchGroupResult(outcome.result()));
-	else
-		return GetFaceSearchGroupOutcome(outcome.error());
-}
-
-void ImmClient::getFaceSearchGroupAsync(const GetFaceSearchGroupRequest& request, const GetFaceSearchGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, getFaceSearchGroup(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::GetFaceSearchGroupOutcomeCallable ImmClient::getFaceSearchGroupCallable(const GetFaceSearchGroupRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<GetFaceSearchGroupOutcome()>>(
-			[this, request]()
-			{
-			return this->getFaceSearchGroup(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::GetVideoOutcome ImmClient::getVideo(const GetVideoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2319,78 +2895,6 @@ ImmClient::ListImagesOutcomeCallable ImmClient::listImagesCallable(const ListIma
 	return task->get_future();
 }
 
-ImmClient::CompareImageFacesOutcome ImmClient::compareImageFaces(const CompareImageFacesRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CompareImageFacesOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CompareImageFacesOutcome(CompareImageFacesResult(outcome.result()));
-	else
-		return CompareImageFacesOutcome(outcome.error());
-}
-
-void ImmClient::compareImageFacesAsync(const CompareImageFacesRequest& request, const CompareImageFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, compareImageFaces(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CompareImageFacesOutcomeCallable ImmClient::compareImageFacesCallable(const CompareImageFacesRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CompareImageFacesOutcome()>>(
-			[this, request]()
-			{
-			return this->compareImageFaces(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::DeleteTagJobOutcome ImmClient::deleteTagJob(const DeleteTagJobRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeleteTagJobOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeleteTagJobOutcome(DeleteTagJobResult(outcome.result()));
-	else
-		return DeleteTagJobOutcome(outcome.error());
-}
-
-void ImmClient::deleteTagJobAsync(const DeleteTagJobRequest& request, const DeleteTagJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deleteTagJob(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DeleteTagJobOutcomeCallable ImmClient::deleteTagJobCallable(const DeleteTagJobRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeleteTagJobOutcome()>>(
-			[this, request]()
-			{
-			return this->deleteTagJob(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DeleteOfficeConversionTaskOutcome ImmClient::deleteOfficeConversionTask(const DeleteOfficeConversionTaskRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2427,42 +2931,6 @@ ImmClient::DeleteOfficeConversionTaskOutcomeCallable ImmClient::deleteOfficeConv
 	return task->get_future();
 }
 
-ImmClient::PhotoProcessOutcome ImmClient::photoProcess(const PhotoProcessRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return PhotoProcessOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return PhotoProcessOutcome(PhotoProcessResult(outcome.result()));
-	else
-		return PhotoProcessOutcome(outcome.error());
-}
-
-void ImmClient::photoProcessAsync(const PhotoProcessRequest& request, const PhotoProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, photoProcess(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::PhotoProcessOutcomeCallable ImmClient::photoProcessCallable(const PhotoProcessRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<PhotoProcessOutcome()>>(
-			[this, request]()
-			{
-			return this->photoProcess(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::GetPhotoProcessTaskOutcome ImmClient::getPhotoProcessTask(const GetPhotoProcessTaskRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2571,36 +3039,36 @@ ImmClient::GetPornBatchDetectJobOutcomeCallable ImmClient::getPornBatchDetectJob
 	return task->get_future();
 }
 
-ImmClient::DetectLogoOutcome ImmClient::detectLogo(const DetectLogoRequest &request) const
+ImmClient::ListTagJobsOutcome ImmClient::listTagJobs(const ListTagJobsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DetectLogoOutcome(endpointOutcome.error());
+		return ListTagJobsOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DetectLogoOutcome(DetectLogoResult(outcome.result()));
+		return ListTagJobsOutcome(ListTagJobsResult(outcome.result()));
 	else
-		return DetectLogoOutcome(outcome.error());
+		return ListTagJobsOutcome(outcome.error());
 }
 
-void ImmClient::detectLogoAsync(const DetectLogoRequest& request, const DetectLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void ImmClient::listTagJobsAsync(const ListTagJobsRequest& request, const ListTagJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, detectLogo(request), context);
+		handler(this, request, listTagJobs(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-ImmClient::DetectLogoOutcomeCallable ImmClient::detectLogoCallable(const DetectLogoRequest &request) const
+ImmClient::ListTagJobsOutcomeCallable ImmClient::listTagJobsCallable(const ListTagJobsRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DetectLogoOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<ListTagJobsOutcome()>>(
 			[this, request]()
 			{
-			return this->detectLogo(request);
+			return this->listTagJobs(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -2643,36 +3111,36 @@ ImmClient::DetectClothesOutcomeCallable ImmClient::detectClothesCallable(const D
 	return task->get_future();
 }
 
-ImmClient::ListTagJobsOutcome ImmClient::listTagJobs(const ListTagJobsRequest &request) const
+ImmClient::DetectLogoOutcome ImmClient::detectLogo(const DetectLogoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return ListTagJobsOutcome(endpointOutcome.error());
+		return DetectLogoOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return ListTagJobsOutcome(ListTagJobsResult(outcome.result()));
+		return DetectLogoOutcome(DetectLogoResult(outcome.result()));
 	else
-		return ListTagJobsOutcome(outcome.error());
+		return DetectLogoOutcome(outcome.error());
 }
 
-void ImmClient::listTagJobsAsync(const ListTagJobsRequest& request, const ListTagJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void ImmClient::detectLogoAsync(const DetectLogoRequest& request, const DetectLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, listTagJobs(request), context);
+		handler(this, request, detectLogo(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-ImmClient::ListTagJobsOutcomeCallable ImmClient::listTagJobsCallable(const ListTagJobsRequest &request) const
+ImmClient::DetectLogoOutcomeCallable ImmClient::detectLogoCallable(const DetectLogoRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<ListTagJobsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DetectLogoOutcome()>>(
 			[this, request]()
 			{
-			return this->listTagJobs(request);
+			return this->detectLogo(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -2715,150 +3183,6 @@ ImmClient::DescribeRegionsOutcomeCallable ImmClient::describeRegionsCallable(con
 	return task->get_future();
 }
 
-ImmClient::DeleteFaceSearchUserOutcome ImmClient::deleteFaceSearchUser(const DeleteFaceSearchUserRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeleteFaceSearchUserOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeleteFaceSearchUserOutcome(DeleteFaceSearchUserResult(outcome.result()));
-	else
-		return DeleteFaceSearchUserOutcome(outcome.error());
-}
-
-void ImmClient::deleteFaceSearchUserAsync(const DeleteFaceSearchUserRequest& request, const DeleteFaceSearchUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deleteFaceSearchUser(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DeleteFaceSearchUserOutcomeCallable ImmClient::deleteFaceSearchUserCallable(const DeleteFaceSearchUserRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeleteFaceSearchUserOutcome()>>(
-			[this, request]()
-			{
-			return this->deleteFaceSearchUser(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::GetOfficeConversionTaskOutcome ImmClient::getOfficeConversionTask(const GetOfficeConversionTaskRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return GetOfficeConversionTaskOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return GetOfficeConversionTaskOutcome(GetOfficeConversionTaskResult(outcome.result()));
-	else
-		return GetOfficeConversionTaskOutcome(outcome.error());
-}
-
-void ImmClient::getOfficeConversionTaskAsync(const GetOfficeConversionTaskRequest& request, const GetOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, getOfficeConversionTask(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::GetOfficeConversionTaskOutcomeCallable ImmClient::getOfficeConversionTaskCallable(const GetOfficeConversionTaskRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<GetOfficeConversionTaskOutcome()>>(
-			[this, request]()
-			{
-			return this->getOfficeConversionTask(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::CreateTagSetOutcome ImmClient::createTagSet(const CreateTagSetRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateTagSetOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateTagSetOutcome(CreateTagSetResult(outcome.result()));
-	else
-		return CreateTagSetOutcome(outcome.error());
-}
-
-void ImmClient::createTagSetAsync(const CreateTagSetRequest& request, const CreateTagSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createTagSet(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreateTagSetOutcomeCallable ImmClient::createTagSetCallable(const CreateTagSetRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateTagSetOutcome()>>(
-			[this, request]()
-			{
-			return this->createTagSet(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::RegistFaceOutcome ImmClient::registFace(const RegistFaceRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return RegistFaceOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return RegistFaceOutcome(RegistFaceResult(outcome.result()));
-	else
-		return RegistFaceOutcome(outcome.error());
-}
-
-void ImmClient::registFaceAsync(const RegistFaceRequest& request, const RegistFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, registFace(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::RegistFaceOutcomeCallable ImmClient::registFaceCallable(const RegistFaceRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<RegistFaceOutcome()>>(
-			[this, request]()
-			{
-			return this->registFace(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::FindSimilarFacesOutcome ImmClient::findSimilarFaces(const FindSimilarFacesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2895,42 +3219,6 @@ ImmClient::FindSimilarFacesOutcomeCallable ImmClient::findSimilarFacesCallable(c
 	return task->get_future();
 }
 
-ImmClient::GetFaceSearchUserOutcome ImmClient::getFaceSearchUser(const GetFaceSearchUserRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return GetFaceSearchUserOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return GetFaceSearchUserOutcome(GetFaceSearchUserResult(outcome.result()));
-	else
-		return GetFaceSearchUserOutcome(outcome.error());
-}
-
-void ImmClient::getFaceSearchUserAsync(const GetFaceSearchUserRequest& request, const GetFaceSearchUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, getFaceSearchUser(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::GetFaceSearchUserOutcomeCallable ImmClient::getFaceSearchUserCallable(const GetFaceSearchUserRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<GetFaceSearchUserOutcome()>>(
-			[this, request]()
-			{
-			return this->getFaceSearchUser(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DeleteImageJobOutcome ImmClient::deleteImageJob(const DeleteImageJobRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2967,42 +3255,6 @@ ImmClient::DeleteImageJobOutcomeCallable ImmClient::deleteImageJobCallable(const
 	return task->get_future();
 }
 
-ImmClient::CreateFaceSetOutcome ImmClient::createFaceSet(const CreateFaceSetRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateFaceSetOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateFaceSetOutcome(CreateFaceSetResult(outcome.result()));
-	else
-		return CreateFaceSetOutcome(outcome.error());
-}
-
-void ImmClient::createFaceSetAsync(const CreateFaceSetRequest& request, const CreateFaceSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createFaceSet(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreateFaceSetOutcomeCallable ImmClient::createFaceSetCallable(const CreateFaceSetRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateFaceSetOutcome()>>(
-			[this, request]()
-			{
-			return this->createFaceSet(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::DeleteFaceSearchGroupOutcome ImmClient::deleteFaceSearchGroup(const DeleteFaceSearchGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3111,42 +3363,6 @@ ImmClient::IndexImageOutcomeCallable ImmClient::indexImageCallable(const IndexIm
 	return task->get_future();
 }
 
-ImmClient::DetectImageTextsOutcome ImmClient::detectImageTexts(const DetectImageTextsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DetectImageTextsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DetectImageTextsOutcome(DetectImageTextsResult(outcome.result()));
-	else
-		return DetectImageTextsOutcome(outcome.error());
-}
-
-void ImmClient::detectImageTextsAsync(const DetectImageTextsRequest& request, const DetectImageTextsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, detectImageTexts(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DetectImageTextsOutcomeCallable ImmClient::detectImageTextsCallable(const DetectImageTextsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DetectImageTextsOutcome()>>(
-			[this, request]()
-			{
-			return this->detectImageTexts(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::ListImageJobsOutcome ImmClient::listImageJobs(const ListImageJobsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3183,42 +3399,6 @@ ImmClient::ListImageJobsOutcomeCallable ImmClient::listImageJobsCallable(const L
 	return task->get_future();
 }
 
-ImmClient::CreateGroupFacesJobOutcome ImmClient::createGroupFacesJob(const CreateGroupFacesJobRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateGroupFacesJobOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateGroupFacesJobOutcome(CreateGroupFacesJobResult(outcome.result()));
-	else
-		return CreateGroupFacesJobOutcome(outcome.error());
-}
-
-void ImmClient::createGroupFacesJobAsync(const CreateGroupFacesJobRequest& request, const CreateGroupFacesJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createGroupFacesJob(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::CreateGroupFacesJobOutcomeCallable ImmClient::createGroupFacesJobCallable(const CreateGroupFacesJobRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateGroupFacesJobOutcome()>>(
-			[this, request]()
-			{
-			return this->createGroupFacesJob(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::UpdateImageOutcome ImmClient::updateImage(const UpdateImageRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3363,78 +3543,6 @@ ImmClient::UpdateProjectOutcomeCallable ImmClient::updateProjectCallable(const U
 	return task->get_future();
 }
 
-ImmClient::DeleteVideoOutcome ImmClient::deleteVideo(const DeleteVideoRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeleteVideoOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeleteVideoOutcome(DeleteVideoResult(outcome.result()));
-	else
-		return DeleteVideoOutcome(outcome.error());
-}
-
-void ImmClient::deleteVideoAsync(const DeleteVideoRequest& request, const DeleteVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deleteVideo(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::DeleteVideoOutcomeCallable ImmClient::deleteVideoCallable(const DeleteVideoRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeleteVideoOutcome()>>(
-			[this, request]()
-			{
-			return this->deleteVideo(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-ImmClient::ListOfficeConversionTaskOutcome ImmClient::listOfficeConversionTask(const ListOfficeConversionTaskRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListOfficeConversionTaskOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListOfficeConversionTaskOutcome(ListOfficeConversionTaskResult(outcome.result()));
-	else
-		return ListOfficeConversionTaskOutcome(outcome.error());
-}
-
-void ImmClient::listOfficeConversionTaskAsync(const ListOfficeConversionTaskRequest& request, const ListOfficeConversionTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listOfficeConversionTask(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::ListOfficeConversionTaskOutcomeCallable ImmClient::listOfficeConversionTaskCallable(const ListOfficeConversionTaskRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListOfficeConversionTaskOutcome()>>(
-			[this, request]()
-			{
-			return this->listOfficeConversionTask(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 ImmClient::UpdateSetOutcome ImmClient::updateSet(const UpdateSetRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3471,39 +3579,3 @@ ImmClient::UpdateSetOutcomeCallable ImmClient::updateSetCallable(const UpdateSet
 	return task->get_future();
 }
 
-ImmClient::ListFaceGroupsOutcome ImmClient::listFaceGroups(const ListFaceGroupsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ListFaceGroupsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ListFaceGroupsOutcome(ListFaceGroupsResult(outcome.result()));
-	else
-		return ListFaceGroupsOutcome(outcome.error());
-}
-
-void ImmClient::listFaceGroupsAsync(const ListFaceGroupsRequest& request, const ListFaceGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, listFaceGroups(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-ImmClient::ListFaceGroupsOutcomeCallable ImmClient::listFaceGroupsCallable(const ListFaceGroupsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ListFaceGroupsOutcome()>>(
-			[this, request]()
-			{
-			return this->listFaceGroups(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
diff --git a/imm/src/model/GetMediaMetaRequest.cc b/imm/src/model/GetMediaMetaRequest.cc
new file mode 100644
index 000000000..a0cf75757
--- /dev/null
+++ b/imm/src/model/GetMediaMetaRequest.cc
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/GetMediaMetaRequest.h>
+
+using AlibabaCloud::Imm::Model::GetMediaMetaRequest;
+
+GetMediaMetaRequest::GetMediaMetaRequest() :
+	RpcServiceRequest("imm", "2017-09-06", "GetMediaMeta")
+{}
+
+GetMediaMetaRequest::~GetMediaMetaRequest()
+{}
+
+std::string GetMediaMetaRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetMediaMetaRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string GetMediaMetaRequest::getMediaUri()const
+{
+	return mediaUri_;
+}
+
+void GetMediaMetaRequest::setMediaUri(const std::string& mediaUri)
+{
+	mediaUri_ = mediaUri;
+	setCoreParameter("MediaUri", mediaUri);
+}
+
+std::string GetMediaMetaRequest::getProject()const
+{
+	return project_;
+}
+
+void GetMediaMetaRequest::setProject(const std::string& project)
+{
+	project_ = project;
+	setCoreParameter("Project", project);
+}
+
+std::string GetMediaMetaRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void GetMediaMetaRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+
diff --git a/imm/src/model/GetMediaMetaResult.cc b/imm/src/model/GetMediaMetaResult.cc
new file mode 100644
index 000000000..2fe047a05
--- /dev/null
+++ b/imm/src/model/GetMediaMetaResult.cc
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/GetMediaMetaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+GetMediaMetaResult::GetMediaMetaResult() :
+	ServiceResult()
+{}
+
+GetMediaMetaResult::GetMediaMetaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetMediaMetaResult::~GetMediaMetaResult()
+{}
+
+void GetMediaMetaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto mediaMetaNode = value["MediaMeta"];
+	auto mediaFormatNode = mediaMetaNode["MediaFormat"];
+	if(!mediaFormatNode["NumberStreams"].isNull())
+		mediaMeta_.mediaFormat.numberStreams = std::stoi(mediaFormatNode["NumberStreams"].asString());
+	if(!mediaFormatNode["NumberPrograms"].isNull())
+		mediaMeta_.mediaFormat.numberPrograms = std::stoi(mediaFormatNode["NumberPrograms"].asString());
+	if(!mediaFormatNode["FormatName"].isNull())
+		mediaMeta_.mediaFormat.formatName = mediaFormatNode["FormatName"].asString();
+	if(!mediaFormatNode["FormatLongName"].isNull())
+		mediaMeta_.mediaFormat.formatLongName = mediaFormatNode["FormatLongName"].asString();
+	if(!mediaFormatNode["Size"].isNull())
+		mediaMeta_.mediaFormat.size = mediaFormatNode["Size"].asString();
+	if(!mediaFormatNode["Duration"].isNull())
+		mediaMeta_.mediaFormat.duration = mediaFormatNode["Duration"].asString();
+	if(!mediaFormatNode["StartTime"].isNull())
+		mediaMeta_.mediaFormat.startTime = mediaFormatNode["StartTime"].asString();
+	if(!mediaFormatNode["Bitrate"].isNull())
+		mediaMeta_.mediaFormat.bitrate = mediaFormatNode["Bitrate"].asString();
+	if(!mediaFormatNode["CreationTime"].isNull())
+		mediaMeta_.mediaFormat.creationTime = mediaFormatNode["CreationTime"].asString();
+	if(!mediaFormatNode["Location"].isNull())
+		mediaMeta_.mediaFormat.location = mediaFormatNode["Location"].asString();
+	auto mediaStreamsNode = mediaMetaNode["MediaStreams"];
+	auto allVideoStreams = value["VideoStreams"]["VideoStream"];
+	for (auto value : allVideoStreams)
+	{
+		MediaMeta::MediaStreams::VideoStream videoStreamObject;
+		if(!value["Index"].isNull())
+			videoStreamObject.index = std::stoi(value["Index"].asString());
+		if(!value["Language"].isNull())
+			videoStreamObject.language = value["Language"].asString();
+		if(!value["CodecName"].isNull())
+			videoStreamObject.codecName = value["CodecName"].asString();
+		if(!value["CodecLongName"].isNull())
+			videoStreamObject.codecLongName = value["CodecLongName"].asString();
+		if(!value["Profile"].isNull())
+			videoStreamObject.profile = value["Profile"].asString();
+		if(!value["CodecTimeBase"].isNull())
+			videoStreamObject.codecTimeBase = value["CodecTimeBase"].asString();
+		if(!value["CodecTagString"].isNull())
+			videoStreamObject.codecTagString = value["CodecTagString"].asString();
+		if(!value["CodecTag"].isNull())
+			videoStreamObject.codecTag = value["CodecTag"].asString();
+		if(!value["Width"].isNull())
+			videoStreamObject.width = std::stoi(value["Width"].asString());
+		if(!value["Height"].isNull())
+			videoStreamObject.height = std::stoi(value["Height"].asString());
+		if(!value["HasBFrames"].isNull())
+			videoStreamObject.hasBFrames = std::stoi(value["HasBFrames"].asString());
+		if(!value["SampleAspectRatio"].isNull())
+			videoStreamObject.sampleAspectRatio = value["SampleAspectRatio"].asString();
+		if(!value["DisplayAspectRatio"].isNull())
+			videoStreamObject.displayAspectRatio = value["DisplayAspectRatio"].asString();
+		if(!value["PixelFormat"].isNull())
+			videoStreamObject.pixelFormat = value["PixelFormat"].asString();
+		if(!value["Level"].isNull())
+			videoStreamObject.level = std::stoi(value["Level"].asString());
+		if(!value["FrameRrate"].isNull())
+			videoStreamObject.frameRrate = value["FrameRrate"].asString();
+		if(!value["AverageFrameRate"].isNull())
+			videoStreamObject.averageFrameRate = value["AverageFrameRate"].asString();
+		if(!value["TimeBase"].isNull())
+			videoStreamObject.timeBase = value["TimeBase"].asString();
+		if(!value["StartTime"].isNull())
+			videoStreamObject.startTime = value["StartTime"].asString();
+		if(!value["Duration"].isNull())
+			videoStreamObject.duration = value["Duration"].asString();
+		if(!value["Bitrate"].isNull())
+			videoStreamObject.bitrate = value["Bitrate"].asString();
+		if(!value["Frames"].isNull())
+			videoStreamObject.frames = value["Frames"].asString();
+		mediaMeta_.mediaStreams.videoStreams.push_back(videoStreamObject);
+	}
+	auto allAudioStreams = value["AudioStreams"]["AudioStream"];
+	for (auto value : allAudioStreams)
+	{
+		MediaMeta::MediaStreams::AudioStream audioStreamObject;
+		if(!value["Index"].isNull())
+			audioStreamObject.index = std::stoi(value["Index"].asString());
+		if(!value["CodecName"].isNull())
+			audioStreamObject.codecName = value["CodecName"].asString();
+		if(!value["CodecLongName"].isNull())
+			audioStreamObject.codecLongName = value["CodecLongName"].asString();
+		if(!value["CodecTimeBase"].isNull())
+			audioStreamObject.codecTimeBase = value["CodecTimeBase"].asString();
+		if(!value["CodecTagString"].isNull())
+			audioStreamObject.codecTagString = value["CodecTagString"].asString();
+		if(!value["CodecTag"].isNull())
+			audioStreamObject.codecTag = value["CodecTag"].asString();
+		if(!value["SampleFormat"].isNull())
+			audioStreamObject.sampleFormat = value["SampleFormat"].asString();
+		if(!value["SampleRate"].isNull())
+			audioStreamObject.sampleRate = value["SampleRate"].asString();
+		if(!value["Channels"].isNull())
+			audioStreamObject.channels = std::stoi(value["Channels"].asString());
+		if(!value["ChannelLayout"].isNull())
+			audioStreamObject.channelLayout = value["ChannelLayout"].asString();
+		if(!value["TimeBase"].isNull())
+			audioStreamObject.timeBase = value["TimeBase"].asString();
+		if(!value["StartTime"].isNull())
+			audioStreamObject.startTime = value["StartTime"].asString();
+		if(!value["Duration"].isNull())
+			audioStreamObject.duration = value["Duration"].asString();
+		if(!value["Bitrate"].isNull())
+			audioStreamObject.bitrate = value["Bitrate"].asString();
+		if(!value["Frames"].isNull())
+			audioStreamObject.frames = value["Frames"].asString();
+		if(!value["Language"].isNull())
+			audioStreamObject.language = value["Language"].asString();
+		mediaMeta_.mediaStreams.audioStreams.push_back(audioStreamObject);
+	}
+	auto allSubtitleStreams = value["SubtitleStreams"]["SubtitleStream"];
+	for (auto value : allSubtitleStreams)
+	{
+		MediaMeta::MediaStreams::SubtitleStream subtitleStreamObject;
+		if(!value["Index"].isNull())
+			subtitleStreamObject.index = std::stoi(value["Index"].asString());
+		if(!value["Language"].isNull())
+			subtitleStreamObject.language = value["Language"].asString();
+		mediaMeta_.mediaStreams.subtitleStreams.push_back(subtitleStreamObject);
+	}
+	if(!value["MediaUri"].isNull())
+		mediaUri_ = value["MediaUri"].asString();
+
+}
+
+std::string GetMediaMetaResult::getMediaUri()const
+{
+	return mediaUri_;
+}
+
+GetMediaMetaResult::MediaMeta GetMediaMetaResult::getMediaMeta()const
+{
+	return mediaMeta_;
+}
+
diff --git a/imm/src/model/GetSetResult.cc b/imm/src/model/GetSetResult.cc
index eade8930f..4ad586182 100644
--- a/imm/src/model/GetSetResult.cc
+++ b/imm/src/model/GetSetResult.cc
@@ -45,9 +45,9 @@ void GetSetResult::parse(const std::string &payload)
 	if(!value["SetName"].isNull())
 		setName_ = value["SetName"].asString();
 	if(!value["CreateTime"].isNull())
-		createTime_ = std::stol(value["CreateTime"].asString());
+		createTime_ = value["CreateTime"].asString();
 	if(!value["ModifyTime"].isNull())
-		modifyTime_ = std::stol(value["ModifyTime"].asString());
+		modifyTime_ = value["ModifyTime"].asString();
 	if(!value["FaceCount"].isNull())
 		faceCount_ = std::stoi(value["FaceCount"].asString());
 	if(!value["ImageCount"].isNull())
@@ -59,7 +59,7 @@ void GetSetResult::parse(const std::string &payload)
 
 }
 
-long GetSetResult::getModifyTime()const
+std::string GetSetResult::getModifyTime()const
 {
 	return modifyTime_;
 }
@@ -74,7 +74,7 @@ int GetSetResult::getVideoCount()const
 	return videoCount_;
 }
 
-long GetSetResult::getCreateTime()const
+std::string GetSetResult::getCreateTime()const
 {
 	return createTime_;
 }
diff --git a/imm/src/model/ListProjectAPIsRequest.cc b/imm/src/model/ListProjectAPIsRequest.cc
new file mode 100644
index 000000000..65d5c94f2
--- /dev/null
+++ b/imm/src/model/ListProjectAPIsRequest.cc
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/ListProjectAPIsRequest.h>
+
+using AlibabaCloud::Imm::Model::ListProjectAPIsRequest;
+
+ListProjectAPIsRequest::ListProjectAPIsRequest() :
+	RpcServiceRequest("imm", "2017-09-06", "ListProjectAPIs")
+{}
+
+ListProjectAPIsRequest::~ListProjectAPIsRequest()
+{}
+
+std::string ListProjectAPIsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListProjectAPIsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string ListProjectAPIsRequest::getProject()const
+{
+	return project_;
+}
+
+void ListProjectAPIsRequest::setProject(const std::string& project)
+{
+	project_ = project;
+	setCoreParameter("Project", project);
+}
+
+std::string ListProjectAPIsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ListProjectAPIsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+
diff --git a/imm/src/model/ListProjectAPIsResult.cc b/imm/src/model/ListProjectAPIsResult.cc
new file mode 100644
index 000000000..562181436
--- /dev/null
+++ b/imm/src/model/ListProjectAPIsResult.cc
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/ListProjectAPIsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+ListProjectAPIsResult::ListProjectAPIsResult() :
+	ServiceResult()
+{}
+
+ListProjectAPIsResult::ListProjectAPIsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListProjectAPIsResult::~ListProjectAPIsResult()
+{}
+
+void ListProjectAPIsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allAPIs = value["APIs"]["APIs"];
+	for (const auto &item : allAPIs)
+		aPIs_.push_back(item.asString());
+	if(!value["Project"].isNull())
+		project_ = value["Project"].asString();
+
+}
+
+std::string ListProjectAPIsResult::getProject()const
+{
+	return project_;
+}
+
+std::vector<std::string> ListProjectAPIsResult::getAPIs()const
+{
+	return aPIs_;
+}
+