Multimedia poc modified.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-04-19 Version: 1.36.364
+- Multimedia poc modified.
+
 2020-04-17 Version: 1.36.363
 - DescribeInstanceTypes support TotalEniQueueQuantity.
 

VERSION

@@ -1 +1 @@
-1.36.363
+1.36.364

multimediaai/CMakeLists.txt

@@ -0,0 +1,138 @@
+#
+# 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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(multimediaai_public_header 
+	include/alibabacloud/multimediaai/MultimediaaiClient.h
+	include/alibabacloud/multimediaai/MultimediaaiExport.h )
+
+set(multimediaai_public_header_model 
+	include/alibabacloud/multimediaai/model/CreateCoverTaskRequest.h
+	include/alibabacloud/multimediaai/model/CreateCoverTaskResult.h
+	include/alibabacloud/multimediaai/model/CreateFaceGroupRequest.h
+	include/alibabacloud/multimediaai/model/CreateFaceGroupResult.h
+	include/alibabacloud/multimediaai/model/CreateFacePersonRequest.h
+	include/alibabacloud/multimediaai/model/CreateFacePersonResult.h
+	include/alibabacloud/multimediaai/model/CreateGifTaskRequest.h
+	include/alibabacloud/multimediaai/model/CreateGifTaskResult.h
+	include/alibabacloud/multimediaai/model/CreateLabelTaskRequest.h
+	include/alibabacloud/multimediaai/model/CreateLabelTaskResult.h
+	include/alibabacloud/multimediaai/model/DeleteFaceGroupRequest.h
+	include/alibabacloud/multimediaai/model/DeleteFaceGroupResult.h
+	include/alibabacloud/multimediaai/model/DeleteFaceImageRequest.h
+	include/alibabacloud/multimediaai/model/DeleteFaceImageResult.h
+	include/alibabacloud/multimediaai/model/DeleteFacePersonRequest.h
+	include/alibabacloud/multimediaai/model/DeleteFacePersonResult.h
+	include/alibabacloud/multimediaai/model/GetTaskResultRequest.h
+	include/alibabacloud/multimediaai/model/GetTaskResultResult.h
+	include/alibabacloud/multimediaai/model/GetTaskStatusRequest.h
+	include/alibabacloud/multimediaai/model/GetTaskStatusResult.h
+	include/alibabacloud/multimediaai/model/ListFaceGroupsRequest.h
+	include/alibabacloud/multimediaai/model/ListFaceGroupsResult.h
+	include/alibabacloud/multimediaai/model/ListFaceImagesRequest.h
+	include/alibabacloud/multimediaai/model/ListFaceImagesResult.h
+	include/alibabacloud/multimediaai/model/ListFacePersonsRequest.h
+	include/alibabacloud/multimediaai/model/ListFacePersonsResult.h
+	include/alibabacloud/multimediaai/model/RegisterFaceImageRequest.h
+	include/alibabacloud/multimediaai/model/RegisterFaceImageResult.h )
+
+set(multimediaai_src 
+	src/MultimediaaiClient.cc
+	src/model/CreateCoverTaskRequest.cc
+	src/model/CreateCoverTaskResult.cc
+	src/model/CreateFaceGroupRequest.cc
+	src/model/CreateFaceGroupResult.cc
+	src/model/CreateFacePersonRequest.cc
+	src/model/CreateFacePersonResult.cc
+	src/model/CreateGifTaskRequest.cc
+	src/model/CreateGifTaskResult.cc
+	src/model/CreateLabelTaskRequest.cc
+	src/model/CreateLabelTaskResult.cc
+	src/model/DeleteFaceGroupRequest.cc
+	src/model/DeleteFaceGroupResult.cc
+	src/model/DeleteFaceImageRequest.cc
+	src/model/DeleteFaceImageResult.cc
+	src/model/DeleteFacePersonRequest.cc
+	src/model/DeleteFacePersonResult.cc
+	src/model/GetTaskResultRequest.cc
+	src/model/GetTaskResultResult.cc
+	src/model/GetTaskStatusRequest.cc
+	src/model/GetTaskStatusResult.cc
+	src/model/ListFaceGroupsRequest.cc
+	src/model/ListFaceGroupsResult.cc
+	src/model/ListFaceImagesRequest.cc
+	src/model/ListFaceImagesResult.cc
+	src/model/ListFacePersonsRequest.cc
+	src/model/ListFacePersonsResult.cc
+	src/model/RegisterFaceImageRequest.cc
+	src/model/RegisterFaceImageResult.cc )
+
+add_library(multimediaai ${LIB_TYPE}
+	${multimediaai_public_header}
+	${multimediaai_public_header_model}
+	${multimediaai_src})
+
+set_target_properties(multimediaai
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}multimediaai
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(multimediaai
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_MULTIMEDIAAI_LIBRARY)
+endif()
+
+target_include_directories(multimediaai
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(multimediaai
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(multimediaai
+		jsoncpp)
+	target_include_directories(multimediaai
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(multimediaai
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(multimediaai
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(multimediaai
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(multimediaai
+		jsoncpp)
+endif()
+
+install(FILES ${multimediaai_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/multimediaai)
+install(FILES ${multimediaai_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/multimediaai/model)
+install(TARGETS multimediaai
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

multimediaai/include/alibabacloud/multimediaai/MultimediaaiClient.h

@@ -0,0 +1,158 @@
+/*
+ * 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_MULTIMEDIAAI_MULTIMEDIAAICLIENT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MULTIMEDIAAICLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "MultimediaaiExport.h"
+#include "model/CreateCoverTaskRequest.h"
+#include "model/CreateCoverTaskResult.h"
+#include "model/CreateFaceGroupRequest.h"
+#include "model/CreateFaceGroupResult.h"
+#include "model/CreateFacePersonRequest.h"
+#include "model/CreateFacePersonResult.h"
+#include "model/CreateGifTaskRequest.h"
+#include "model/CreateGifTaskResult.h"
+#include "model/CreateLabelTaskRequest.h"
+#include "model/CreateLabelTaskResult.h"
+#include "model/DeleteFaceGroupRequest.h"
+#include "model/DeleteFaceGroupResult.h"
+#include "model/DeleteFaceImageRequest.h"
+#include "model/DeleteFaceImageResult.h"
+#include "model/DeleteFacePersonRequest.h"
+#include "model/DeleteFacePersonResult.h"
+#include "model/GetTaskResultRequest.h"
+#include "model/GetTaskResultResult.h"
+#include "model/GetTaskStatusRequest.h"
+#include "model/GetTaskStatusResult.h"
+#include "model/ListFaceGroupsRequest.h"
+#include "model/ListFaceGroupsResult.h"
+#include "model/ListFaceImagesRequest.h"
+#include "model/ListFaceImagesResult.h"
+#include "model/ListFacePersonsRequest.h"
+#include "model/ListFacePersonsResult.h"
+#include "model/RegisterFaceImageRequest.h"
+#include "model/RegisterFaceImageResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		class ALIBABACLOUD_MULTIMEDIAAI_EXPORT MultimediaaiClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::CreateCoverTaskResult> CreateCoverTaskOutcome;
+			typedef std::future<CreateCoverTaskOutcome> CreateCoverTaskOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::CreateCoverTaskRequest&, const CreateCoverTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCoverTaskAsyncHandler;
+			typedef Outcome<Error, Model::CreateFaceGroupResult> CreateFaceGroupOutcome;
+			typedef std::future<CreateFaceGroupOutcome> CreateFaceGroupOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::CreateFaceGroupRequest&, const CreateFaceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFaceGroupAsyncHandler;
+			typedef Outcome<Error, Model::CreateFacePersonResult> CreateFacePersonOutcome;
+			typedef std::future<CreateFacePersonOutcome> CreateFacePersonOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::CreateFacePersonRequest&, const CreateFacePersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFacePersonAsyncHandler;
+			typedef Outcome<Error, Model::CreateGifTaskResult> CreateGifTaskOutcome;
+			typedef std::future<CreateGifTaskOutcome> CreateGifTaskOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::CreateGifTaskRequest&, const CreateGifTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGifTaskAsyncHandler;
+			typedef Outcome<Error, Model::CreateLabelTaskResult> CreateLabelTaskOutcome;
+			typedef std::future<CreateLabelTaskOutcome> CreateLabelTaskOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::CreateLabelTaskRequest&, const CreateLabelTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLabelTaskAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFaceGroupResult> DeleteFaceGroupOutcome;
+			typedef std::future<DeleteFaceGroupOutcome> DeleteFaceGroupOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::DeleteFaceGroupRequest&, const DeleteFaceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceGroupAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFaceImageResult> DeleteFaceImageOutcome;
+			typedef std::future<DeleteFaceImageOutcome> DeleteFaceImageOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::DeleteFaceImageRequest&, const DeleteFaceImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceImageAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFacePersonResult> DeleteFacePersonOutcome;
+			typedef std::future<DeleteFacePersonOutcome> DeleteFacePersonOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::DeleteFacePersonRequest&, const DeleteFacePersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFacePersonAsyncHandler;
+			typedef Outcome<Error, Model::GetTaskResultResult> GetTaskResultOutcome;
+			typedef std::future<GetTaskResultOutcome> GetTaskResultOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::GetTaskResultRequest&, const GetTaskResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTaskResultAsyncHandler;
+			typedef Outcome<Error, Model::GetTaskStatusResult> GetTaskStatusOutcome;
+			typedef std::future<GetTaskStatusOutcome> GetTaskStatusOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::GetTaskStatusRequest&, const GetTaskStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTaskStatusAsyncHandler;
+			typedef Outcome<Error, Model::ListFaceGroupsResult> ListFaceGroupsOutcome;
+			typedef std::future<ListFaceGroupsOutcome> ListFaceGroupsOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ListFaceGroupsRequest&, const ListFaceGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ListFaceImagesResult> ListFaceImagesOutcome;
+			typedef std::future<ListFaceImagesOutcome> ListFaceImagesOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ListFaceImagesRequest&, const ListFaceImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceImagesAsyncHandler;
+			typedef Outcome<Error, Model::ListFacePersonsResult> ListFacePersonsOutcome;
+			typedef std::future<ListFacePersonsOutcome> ListFacePersonsOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ListFacePersonsRequest&, const ListFacePersonsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFacePersonsAsyncHandler;
+			typedef Outcome<Error, Model::RegisterFaceImageResult> RegisterFaceImageOutcome;
+			typedef std::future<RegisterFaceImageOutcome> RegisterFaceImageOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::RegisterFaceImageRequest&, const RegisterFaceImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RegisterFaceImageAsyncHandler;
+
+			MultimediaaiClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			MultimediaaiClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			MultimediaaiClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~MultimediaaiClient();
+			CreateCoverTaskOutcome createCoverTask(const Model::CreateCoverTaskRequest &request)const;
+			void createCoverTaskAsync(const Model::CreateCoverTaskRequest& request, const CreateCoverTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCoverTaskOutcomeCallable createCoverTaskCallable(const Model::CreateCoverTaskRequest& request) const;
+			CreateFaceGroupOutcome createFaceGroup(const Model::CreateFaceGroupRequest &request)const;
+			void createFaceGroupAsync(const Model::CreateFaceGroupRequest& request, const CreateFaceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateFaceGroupOutcomeCallable createFaceGroupCallable(const Model::CreateFaceGroupRequest& request) const;
+			CreateFacePersonOutcome createFacePerson(const Model::CreateFacePersonRequest &request)const;
+			void createFacePersonAsync(const Model::CreateFacePersonRequest& request, const CreateFacePersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateFacePersonOutcomeCallable createFacePersonCallable(const Model::CreateFacePersonRequest& request) const;
+			CreateGifTaskOutcome createGifTask(const Model::CreateGifTaskRequest &request)const;
+			void createGifTaskAsync(const Model::CreateGifTaskRequest& request, const CreateGifTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGifTaskOutcomeCallable createGifTaskCallable(const Model::CreateGifTaskRequest& request) const;
+			CreateLabelTaskOutcome createLabelTask(const Model::CreateLabelTaskRequest &request)const;
+			void createLabelTaskAsync(const Model::CreateLabelTaskRequest& request, const CreateLabelTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateLabelTaskOutcomeCallable createLabelTaskCallable(const Model::CreateLabelTaskRequest& request) const;
+			DeleteFaceGroupOutcome deleteFaceGroup(const Model::DeleteFaceGroupRequest &request)const;
+			void deleteFaceGroupAsync(const Model::DeleteFaceGroupRequest& request, const DeleteFaceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFaceGroupOutcomeCallable deleteFaceGroupCallable(const Model::DeleteFaceGroupRequest& request) const;
+			DeleteFaceImageOutcome deleteFaceImage(const Model::DeleteFaceImageRequest &request)const;
+			void deleteFaceImageAsync(const Model::DeleteFaceImageRequest& request, const DeleteFaceImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFaceImageOutcomeCallable deleteFaceImageCallable(const Model::DeleteFaceImageRequest& request) const;
+			DeleteFacePersonOutcome deleteFacePerson(const Model::DeleteFacePersonRequest &request)const;
+			void deleteFacePersonAsync(const Model::DeleteFacePersonRequest& request, const DeleteFacePersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFacePersonOutcomeCallable deleteFacePersonCallable(const Model::DeleteFacePersonRequest& request) const;
+			GetTaskResultOutcome getTaskResult(const Model::GetTaskResultRequest &request)const;
+			void getTaskResultAsync(const Model::GetTaskResultRequest& request, const GetTaskResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTaskResultOutcomeCallable getTaskResultCallable(const Model::GetTaskResultRequest& request) const;
+			GetTaskStatusOutcome getTaskStatus(const Model::GetTaskStatusRequest &request)const;
+			void getTaskStatusAsync(const Model::GetTaskStatusRequest& request, const GetTaskStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTaskStatusOutcomeCallable getTaskStatusCallable(const Model::GetTaskStatusRequest& 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;
+			ListFaceImagesOutcome listFaceImages(const Model::ListFaceImagesRequest &request)const;
+			void listFaceImagesAsync(const Model::ListFaceImagesRequest& request, const ListFaceImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFaceImagesOutcomeCallable listFaceImagesCallable(const Model::ListFaceImagesRequest& request) const;
+			ListFacePersonsOutcome listFacePersons(const Model::ListFacePersonsRequest &request)const;
+			void listFacePersonsAsync(const Model::ListFacePersonsRequest& request, const ListFacePersonsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFacePersonsOutcomeCallable listFacePersonsCallable(const Model::ListFacePersonsRequest& request) const;
+			RegisterFaceImageOutcome registerFaceImage(const Model::RegisterFaceImageRequest &request)const;
+			void registerFaceImageAsync(const Model::RegisterFaceImageRequest& request, const RegisterFaceImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RegisterFaceImageOutcomeCallable registerFaceImageCallable(const Model::RegisterFaceImageRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MULTIMEDIAAICLIENT_H_

multimediaai/include/alibabacloud/multimediaai/MultimediaaiExport.h

@@ -0,0 +1,32 @@
+/*
+ * 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_MULTIMEDIAAI_MULTIMEDIAAIEXPORT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MULTIMEDIAAIEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_MULTIMEDIAAI_LIBRARY)
+#		define ALIBABACLOUD_MULTIMEDIAAI_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_MULTIMEDIAAI_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_MULTIMEDIAAI_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MULTIMEDIAAIEXPORT_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateCoverTaskRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATECOVERTASKREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATECOVERTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateCoverTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateCoverTaskRequest();
+				~CreateCoverTaskRequest();
+
+				long getTemplateId()const;
+				void setTemplateId(long templateId);
+				std::string getVideoUrl()const;
+				void setVideoUrl(const std::string& videoUrl);
+				std::string getVideoName()const;
+				void setVideoName(const std::string& videoName);
+				std::string getCallbackUrl()const;
+				void setCallbackUrl(const std::string& callbackUrl);
+				std::string getApplicationId()const;
+				void setApplicationId(const std::string& applicationId);
+
+            private:
+				long templateId_;
+				std::string videoUrl_;
+				std::string videoName_;
+				std::string callbackUrl_;
+				std::string applicationId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATECOVERTASKREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateCoverTaskResult.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_CREATECOVERTASKRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATECOVERTASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateCoverTaskResult : public ServiceResult
+			{
+			public:
+
+
+				CreateCoverTaskResult();
+				explicit CreateCoverTaskResult(const std::string &payload);
+				~CreateCoverTaskResult();
+				long getTaskId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATECOVERTASKRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateFaceGroupRequest.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_CREATEFACEGROUPREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEFACEGROUPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateFaceGroupRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateFaceGroupRequest();
+				~CreateFaceGroupRequest();
+
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getFaceGroupName()const;
+				void setFaceGroupName(const std::string& faceGroupName);
+
+            private:
+				std::string description_;
+				std::string faceGroupName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEFACEGROUPREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateFaceGroupResult.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_CREATEFACEGROUPRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEFACEGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateFaceGroupResult : public ServiceResult
+			{
+			public:
+
+
+				CreateFaceGroupResult();
+				explicit CreateFaceGroupResult(const std::string &payload);
+				~CreateFaceGroupResult();
+				long getFaceGroupId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long faceGroupId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEFACEGROUPRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateFacePersonRequest.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_MULTIMEDIAAI_MODEL_CREATEFACEPERSONREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEFACEPERSONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateFacePersonRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateFacePersonRequest();
+				~CreateFacePersonRequest();
+
+				long getFaceGroupId()const;
+				void setFaceGroupId(long faceGroupId);
+				std::string getImageUrls()const;
+				void setImageUrls(const std::string& imageUrls);
+				std::string getFacePersonName()const;
+				void setFacePersonName(const std::string& facePersonName);
+
+            private:
+				long faceGroupId_;
+				std::string imageUrls_;
+				std::string facePersonName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEFACEPERSONREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateFacePersonResult.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_CREATEFACEPERSONRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEFACEPERSONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateFacePersonResult : public ServiceResult
+			{
+			public:
+
+
+				CreateFacePersonResult();
+				explicit CreateFacePersonResult(const std::string &payload);
+				~CreateFacePersonResult();
+				long getFacePersonId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long facePersonId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEFACEPERSONRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateGifTaskRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEGIFTASKREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEGIFTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateGifTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateGifTaskRequest();
+				~CreateGifTaskRequest();
+
+				long getTemplateId()const;
+				void setTemplateId(long templateId);
+				std::string getVideoUrl()const;
+				void setVideoUrl(const std::string& videoUrl);
+				std::string getVideoName()const;
+				void setVideoName(const std::string& videoName);
+				std::string getCallbackUrl()const;
+				void setCallbackUrl(const std::string& callbackUrl);
+				std::string getApplicationId()const;
+				void setApplicationId(const std::string& applicationId);
+
+            private:
+				long templateId_;
+				std::string videoUrl_;
+				std::string videoName_;
+				std::string callbackUrl_;
+				std::string applicationId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEGIFTASKREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateGifTaskResult.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_CREATEGIFTASKRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEGIFTASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateGifTaskResult : public ServiceResult
+			{
+			public:
+
+
+				CreateGifTaskResult();
+				explicit CreateGifTaskResult(const std::string &payload);
+				~CreateGifTaskResult();
+				long getTaskId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATEGIFTASKRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateLabelTaskRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATELABELTASKREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATELABELTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateLabelTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateLabelTaskRequest();
+				~CreateLabelTaskRequest();
+
+				long getTemplateId()const;
+				void setTemplateId(long templateId);
+				std::string getVideoUrl()const;
+				void setVideoUrl(const std::string& videoUrl);
+				std::string getVideoName()const;
+				void setVideoName(const std::string& videoName);
+				std::string getCallbackUrl()const;
+				void setCallbackUrl(const std::string& callbackUrl);
+				std::string getApplicationId()const;
+				void setApplicationId(const std::string& applicationId);
+
+            private:
+				long templateId_;
+				std::string videoUrl_;
+				std::string videoName_;
+				std::string callbackUrl_;
+				std::string applicationId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATELABELTASKREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/CreateLabelTaskResult.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_CREATELABELTASKRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATELABELTASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT CreateLabelTaskResult : public ServiceResult
+			{
+			public:
+
+
+				CreateLabelTaskResult();
+				explicit CreateLabelTaskResult(const std::string &payload);
+				~CreateLabelTaskResult();
+				long getTaskId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_CREATELABELTASKRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/DeleteFaceGroupRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_DELETEFACEGROUPREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEGROUPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT DeleteFaceGroupRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteFaceGroupRequest();
+				~DeleteFaceGroupRequest();
+
+				long getFaceGroupId()const;
+				void setFaceGroupId(long faceGroupId);
+
+            private:
+				long faceGroupId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEGROUPREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/DeleteFaceGroupResult.h

@@ -0,0 +1,49 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_DELETEFACEGROUPRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT DeleteFaceGroupResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteFaceGroupResult();
+				explicit DeleteFaceGroupResult(const std::string &payload);
+				~DeleteFaceGroupResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEGROUPRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/DeleteFaceImageRequest.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_MULTIMEDIAAI_MODEL_DELETEFACEIMAGEREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEIMAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT DeleteFaceImageRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteFaceImageRequest();
+				~DeleteFaceImageRequest();
+
+				long getFaceGroupId()const;
+				void setFaceGroupId(long faceGroupId);
+				long getFacePersonId()const;
+				void setFacePersonId(long facePersonId);
+				long getFaceImageId()const;
+				void setFaceImageId(long faceImageId);
+
+            private:
+				long faceGroupId_;
+				long facePersonId_;
+				long faceImageId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEIMAGEREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/DeleteFaceImageResult.h

@@ -0,0 +1,49 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_DELETEFACEIMAGERESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT DeleteFaceImageResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteFaceImageResult();
+				explicit DeleteFaceImageResult(const std::string &payload);
+				~DeleteFaceImageResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEIMAGERESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/DeleteFacePersonRequest.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_DELETEFACEPERSONREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEPERSONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT DeleteFacePersonRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteFacePersonRequest();
+				~DeleteFacePersonRequest();
+
+				long getFaceGroupId()const;
+				void setFaceGroupId(long faceGroupId);
+				long getFacePersonId()const;
+				void setFacePersonId(long facePersonId);
+
+            private:
+				long faceGroupId_;
+				long facePersonId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEPERSONREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/DeleteFacePersonResult.h

@@ -0,0 +1,49 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_DELETEFACEPERSONRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEPERSONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT DeleteFacePersonResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteFacePersonResult();
+				explicit DeleteFacePersonResult(const std::string &payload);
+				~DeleteFacePersonResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_DELETEFACEPERSONRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/GetTaskResultRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_GETTASKRESULTREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_GETTASKRESULTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT GetTaskResultRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetTaskResultRequest();
+				~GetTaskResultRequest();
+
+				long getTaskId()const;
+				void setTaskId(long taskId);
+
+            private:
+				long taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_GETTASKRESULTREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/GetTaskResultResult.h

@@ -0,0 +1,65 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_GETTASKRESULTRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_GETTASKRESULTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT GetTaskResultResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					std::string errorName;
+					std::string videoName;
+					long analysisUseTime;
+					std::string errorReason;
+					std::string errorCode;
+					std::string applicationId;
+					std::string errorMessage;
+					std::string processResultUrl;
+					std::string videoUrl;
+				};
+
+
+				GetTaskResultResult();
+				explicit GetTaskResultResult(const std::string &payload);
+				~GetTaskResultResult();
+				int getStatus()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int status_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_GETTASKRESULTRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/GetTaskStatusRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_GETTASKSTATUSREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_GETTASKSTATUSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT GetTaskStatusRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetTaskStatusRequest();
+				~GetTaskStatusRequest();
+
+				long getTaskId()const;
+				void setTaskId(long taskId);
+
+            private:
+				long taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_GETTASKSTATUSREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/GetTaskStatusResult.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_GETTASKSTATUSRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_GETTASKSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT GetTaskStatusResult : public ServiceResult
+			{
+			public:
+
+
+				GetTaskStatusResult();
+				explicit GetTaskStatusResult(const std::string &payload);
+				~GetTaskStatusResult();
+				int getStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_GETTASKSTATUSRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/ListFaceGroupsRequest.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_LISTFACEGROUPSREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEGROUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ListFaceGroupsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListFaceGroupsRequest();
+				~ListFaceGroupsRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEGROUPSREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ListFaceGroupsResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEGROUPSRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ListFaceGroupsResult : public ServiceResult
+			{
+			public:
+				struct FaceGroup
+				{
+					struct TemplatesItem
+					{
+						std::string id;
+						std::string name;
+					};
+					long imageCount;
+					std::string description;
+					std::string faceGroupName;
+					long personCount;
+					std::vector<FaceGroup::TemplatesItem> templates;
+					long faceGroupId;
+				};
+
+
+				ListFaceGroupsResult();
+				explicit ListFaceGroupsResult(const std::string &payload);
+				~ListFaceGroupsResult();
+				long getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<FaceGroup> getFaceGroups()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<FaceGroup> faceGroups_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEGROUPSRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/ListFaceImagesRequest.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_MULTIMEDIAAI_MODEL_LISTFACEIMAGESREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEIMAGESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ListFaceImagesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListFaceImagesRequest();
+				~ListFaceImagesRequest();
+
+				long getFaceGroupId()const;
+				void setFaceGroupId(long faceGroupId);
+				long getFacePersonId()const;
+				void setFacePersonId(long facePersonId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				long faceGroupId_;
+				long facePersonId_;
+				int pageNumber_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEIMAGESREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ListFaceImagesResult.h

@@ -0,0 +1,63 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_LISTFACEIMAGESRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEIMAGESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ListFaceImagesResult : public ServiceResult
+			{
+			public:
+				struct FaceImage
+				{
+					long faceImageId;
+					std::vector<std::string> faceRectangle;
+					std::string imageUrl;
+				};
+
+
+				ListFaceImagesResult();
+				explicit ListFaceImagesResult(const std::string &payload);
+				~ListFaceImagesResult();
+				long getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<FaceImage> getFaceImages()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<FaceImage> faceImages_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEIMAGESRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/ListFacePersonsRequest.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_MULTIMEDIAAI_MODEL_LISTFACEPERSONSREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEPERSONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ListFacePersonsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListFacePersonsRequest();
+				~ListFacePersonsRequest();
+
+				long getFaceGroupId()const;
+				void setFaceGroupId(long faceGroupId);
+				std::string getFacePersonName()const;
+				void setFacePersonName(const std::string& facePersonName);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				long faceGroupId_;
+				std::string facePersonName_;
+				int pageNumber_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEPERSONSREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ListFacePersonsResult.h

@@ -0,0 +1,64 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_LISTFACEPERSONSRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEPERSONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ListFacePersonsResult : public ServiceResult
+			{
+			public:
+				struct FacePerson
+				{
+					long imageCount;
+					std::string facePersonName;
+					std::string imageUrl;
+					long facePersonId;
+				};
+
+
+				ListFacePersonsResult();
+				explicit ListFacePersonsResult(const std::string &payload);
+				~ListFacePersonsResult();
+				long getTotalCount()const;
+				std::vector<FacePerson> getFacePersons()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::vector<FacePerson> facePersons_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_LISTFACEPERSONSRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/RegisterFaceImageRequest.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_MULTIMEDIAAI_MODEL_REGISTERFACEIMAGEREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_REGISTERFACEIMAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT RegisterFaceImageRequest : public RpcServiceRequest
+			{
+
+			public:
+				RegisterFaceImageRequest();
+				~RegisterFaceImageRequest();
+
+				long getFaceGroupId()const;
+				void setFaceGroupId(long faceGroupId);
+				long getFacePersonId()const;
+				void setFacePersonId(long facePersonId);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+
+            private:
+				long faceGroupId_;
+				long facePersonId_;
+				std::string imageUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_REGISTERFACEIMAGEREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/RegisterFaceImageResult.h

@@ -0,0 +1,49 @@
+/*
+ * 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_MULTIMEDIAAI_MODEL_REGISTERFACEIMAGERESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_REGISTERFACEIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT RegisterFaceImageResult : public ServiceResult
+			{
+			public:
+
+
+				RegisterFaceImageResult();
+				explicit RegisterFaceImageResult(const std::string &payload);
+				~RegisterFaceImageResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_REGISTERFACEIMAGERESULT_H_

multimediaai/src/MultimediaaiClient.cc

@@ -0,0 +1,557 @@
+/*
+ * 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/multimediaai/MultimediaaiClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "multimediaai";
+}
+
+MultimediaaiClient::MultimediaaiClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+MultimediaaiClient::MultimediaaiClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+MultimediaaiClient::MultimediaaiClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+MultimediaaiClient::~MultimediaaiClient()
+{}
+
+MultimediaaiClient::CreateCoverTaskOutcome MultimediaaiClient::createCoverTask(const CreateCoverTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateCoverTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateCoverTaskOutcome(CreateCoverTaskResult(outcome.result()));
+	else
+		return CreateCoverTaskOutcome(outcome.error());
+}
+
+void MultimediaaiClient::createCoverTaskAsync(const CreateCoverTaskRequest& request, const CreateCoverTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createCoverTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::CreateCoverTaskOutcomeCallable MultimediaaiClient::createCoverTaskCallable(const CreateCoverTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateCoverTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->createCoverTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::CreateFaceGroupOutcome MultimediaaiClient::createFaceGroup(const CreateFaceGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateFaceGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateFaceGroupOutcome(CreateFaceGroupResult(outcome.result()));
+	else
+		return CreateFaceGroupOutcome(outcome.error());
+}
+
+void MultimediaaiClient::createFaceGroupAsync(const CreateFaceGroupRequest& request, const CreateFaceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createFaceGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::CreateFaceGroupOutcomeCallable MultimediaaiClient::createFaceGroupCallable(const CreateFaceGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateFaceGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->createFaceGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::CreateFacePersonOutcome MultimediaaiClient::createFacePerson(const CreateFacePersonRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateFacePersonOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateFacePersonOutcome(CreateFacePersonResult(outcome.result()));
+	else
+		return CreateFacePersonOutcome(outcome.error());
+}
+
+void MultimediaaiClient::createFacePersonAsync(const CreateFacePersonRequest& request, const CreateFacePersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createFacePerson(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::CreateFacePersonOutcomeCallable MultimediaaiClient::createFacePersonCallable(const CreateFacePersonRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateFacePersonOutcome()>>(
+			[this, request]()
+			{
+			return this->createFacePerson(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::CreateGifTaskOutcome MultimediaaiClient::createGifTask(const CreateGifTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateGifTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateGifTaskOutcome(CreateGifTaskResult(outcome.result()));
+	else
+		return CreateGifTaskOutcome(outcome.error());
+}
+
+void MultimediaaiClient::createGifTaskAsync(const CreateGifTaskRequest& request, const CreateGifTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createGifTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::CreateGifTaskOutcomeCallable MultimediaaiClient::createGifTaskCallable(const CreateGifTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateGifTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->createGifTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::CreateLabelTaskOutcome MultimediaaiClient::createLabelTask(const CreateLabelTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateLabelTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateLabelTaskOutcome(CreateLabelTaskResult(outcome.result()));
+	else
+		return CreateLabelTaskOutcome(outcome.error());
+}
+
+void MultimediaaiClient::createLabelTaskAsync(const CreateLabelTaskRequest& request, const CreateLabelTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createLabelTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::CreateLabelTaskOutcomeCallable MultimediaaiClient::createLabelTaskCallable(const CreateLabelTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateLabelTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->createLabelTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::DeleteFaceGroupOutcome MultimediaaiClient::deleteFaceGroup(const DeleteFaceGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFaceGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFaceGroupOutcome(DeleteFaceGroupResult(outcome.result()));
+	else
+		return DeleteFaceGroupOutcome(outcome.error());
+}
+
+void MultimediaaiClient::deleteFaceGroupAsync(const DeleteFaceGroupRequest& request, const DeleteFaceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFaceGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::DeleteFaceGroupOutcomeCallable MultimediaaiClient::deleteFaceGroupCallable(const DeleteFaceGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFaceGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFaceGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::DeleteFaceImageOutcome MultimediaaiClient::deleteFaceImage(const DeleteFaceImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFaceImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFaceImageOutcome(DeleteFaceImageResult(outcome.result()));
+	else
+		return DeleteFaceImageOutcome(outcome.error());
+}
+
+void MultimediaaiClient::deleteFaceImageAsync(const DeleteFaceImageRequest& request, const DeleteFaceImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFaceImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::DeleteFaceImageOutcomeCallable MultimediaaiClient::deleteFaceImageCallable(const DeleteFaceImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFaceImageOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFaceImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::DeleteFacePersonOutcome MultimediaaiClient::deleteFacePerson(const DeleteFacePersonRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFacePersonOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFacePersonOutcome(DeleteFacePersonResult(outcome.result()));
+	else
+		return DeleteFacePersonOutcome(outcome.error());
+}
+
+void MultimediaaiClient::deleteFacePersonAsync(const DeleteFacePersonRequest& request, const DeleteFacePersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFacePerson(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::DeleteFacePersonOutcomeCallable MultimediaaiClient::deleteFacePersonCallable(const DeleteFacePersonRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFacePersonOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFacePerson(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::GetTaskResultOutcome MultimediaaiClient::getTaskResult(const GetTaskResultRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTaskResultOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTaskResultOutcome(GetTaskResultResult(outcome.result()));
+	else
+		return GetTaskResultOutcome(outcome.error());
+}
+
+void MultimediaaiClient::getTaskResultAsync(const GetTaskResultRequest& request, const GetTaskResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTaskResult(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::GetTaskResultOutcomeCallable MultimediaaiClient::getTaskResultCallable(const GetTaskResultRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTaskResultOutcome()>>(
+			[this, request]()
+			{
+			return this->getTaskResult(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::GetTaskStatusOutcome MultimediaaiClient::getTaskStatus(const GetTaskStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTaskStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTaskStatusOutcome(GetTaskStatusResult(outcome.result()));
+	else
+		return GetTaskStatusOutcome(outcome.error());
+}
+
+void MultimediaaiClient::getTaskStatusAsync(const GetTaskStatusRequest& request, const GetTaskStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTaskStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::GetTaskStatusOutcomeCallable MultimediaaiClient::getTaskStatusCallable(const GetTaskStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTaskStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getTaskStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::ListFaceGroupsOutcome MultimediaaiClient::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 MultimediaaiClient::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));
+}
+
+MultimediaaiClient::ListFaceGroupsOutcomeCallable MultimediaaiClient::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();
+}
+
+MultimediaaiClient::ListFaceImagesOutcome MultimediaaiClient::listFaceImages(const ListFaceImagesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListFaceImagesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListFaceImagesOutcome(ListFaceImagesResult(outcome.result()));
+	else
+		return ListFaceImagesOutcome(outcome.error());
+}
+
+void MultimediaaiClient::listFaceImagesAsync(const ListFaceImagesRequest& request, const ListFaceImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listFaceImages(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::ListFaceImagesOutcomeCallable MultimediaaiClient::listFaceImagesCallable(const ListFaceImagesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListFaceImagesOutcome()>>(
+			[this, request]()
+			{
+			return this->listFaceImages(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::ListFacePersonsOutcome MultimediaaiClient::listFacePersons(const ListFacePersonsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListFacePersonsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListFacePersonsOutcome(ListFacePersonsResult(outcome.result()));
+	else
+		return ListFacePersonsOutcome(outcome.error());
+}
+
+void MultimediaaiClient::listFacePersonsAsync(const ListFacePersonsRequest& request, const ListFacePersonsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listFacePersons(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::ListFacePersonsOutcomeCallable MultimediaaiClient::listFacePersonsCallable(const ListFacePersonsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListFacePersonsOutcome()>>(
+			[this, request]()
+			{
+			return this->listFacePersons(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::RegisterFaceImageOutcome MultimediaaiClient::registerFaceImage(const RegisterFaceImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RegisterFaceImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RegisterFaceImageOutcome(RegisterFaceImageResult(outcome.result()));
+	else
+		return RegisterFaceImageOutcome(outcome.error());
+}
+
+void MultimediaaiClient::registerFaceImageAsync(const RegisterFaceImageRequest& request, const RegisterFaceImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, registerFaceImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::RegisterFaceImageOutcomeCallable MultimediaaiClient::registerFaceImageCallable(const RegisterFaceImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RegisterFaceImageOutcome()>>(
+			[this, request]()
+			{
+			return this->registerFaceImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

multimediaai/src/model/CreateCoverTaskRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/multimediaai/model/CreateCoverTaskRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::CreateCoverTaskRequest;
+
+CreateCoverTaskRequest::CreateCoverTaskRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "CreateCoverTask")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateCoverTaskRequest::~CreateCoverTaskRequest()
+{}
+
+long CreateCoverTaskRequest::getTemplateId()const
+{
+	return templateId_;
+}
+
+void CreateCoverTaskRequest::setTemplateId(long templateId)
+{
+	templateId_ = templateId;
+	setParameter("TemplateId", std::to_string(templateId));
+}
+
+std::string CreateCoverTaskRequest::getVideoUrl()const
+{
+	return videoUrl_;
+}
+
+void CreateCoverTaskRequest::setVideoUrl(const std::string& videoUrl)
+{
+	videoUrl_ = videoUrl;
+	setParameter("VideoUrl", videoUrl);
+}
+
+std::string CreateCoverTaskRequest::getVideoName()const
+{
+	return videoName_;
+}
+
+void CreateCoverTaskRequest::setVideoName(const std::string& videoName)
+{
+	videoName_ = videoName;
+	setParameter("VideoName", videoName);
+}
+
+std::string CreateCoverTaskRequest::getCallbackUrl()const
+{
+	return callbackUrl_;
+}
+
+void CreateCoverTaskRequest::setCallbackUrl(const std::string& callbackUrl)
+{
+	callbackUrl_ = callbackUrl;
+	setParameter("CallbackUrl", callbackUrl);
+}
+
+std::string CreateCoverTaskRequest::getApplicationId()const
+{
+	return applicationId_;
+}
+
+void CreateCoverTaskRequest::setApplicationId(const std::string& applicationId)
+{
+	applicationId_ = applicationId;
+	setParameter("ApplicationId", applicationId);
+}
+

multimediaai/src/model/CreateCoverTaskResult.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/multimediaai/model/CreateCoverTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+CreateCoverTaskResult::CreateCoverTaskResult() :
+	ServiceResult()
+{}
+
+CreateCoverTaskResult::CreateCoverTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateCoverTaskResult::~CreateCoverTaskResult()
+{}
+
+void CreateCoverTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = std::stol(value["TaskId"].asString());
+
+}
+
+long CreateCoverTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+

multimediaai/src/model/CreateFaceGroupRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/multimediaai/model/CreateFaceGroupRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::CreateFaceGroupRequest;
+
+CreateFaceGroupRequest::CreateFaceGroupRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "CreateFaceGroup")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateFaceGroupRequest::~CreateFaceGroupRequest()
+{}
+
+std::string CreateFaceGroupRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateFaceGroupRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateFaceGroupRequest::getFaceGroupName()const
+{
+	return faceGroupName_;
+}
+
+void CreateFaceGroupRequest::setFaceGroupName(const std::string& faceGroupName)
+{
+	faceGroupName_ = faceGroupName;
+	setParameter("FaceGroupName", faceGroupName);
+}
+

multimediaai/src/model/CreateFaceGroupResult.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/multimediaai/model/CreateFaceGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+CreateFaceGroupResult::CreateFaceGroupResult() :
+	ServiceResult()
+{}
+
+CreateFaceGroupResult::CreateFaceGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateFaceGroupResult::~CreateFaceGroupResult()
+{}
+
+void CreateFaceGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["FaceGroupId"].isNull())
+		faceGroupId_ = std::stol(value["FaceGroupId"].asString());
+
+}
+
+long CreateFaceGroupResult::getFaceGroupId()const
+{
+	return faceGroupId_;
+}
+

multimediaai/src/model/CreateFacePersonRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * 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/multimediaai/model/CreateFacePersonRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::CreateFacePersonRequest;
+
+CreateFacePersonRequest::CreateFacePersonRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "CreateFacePerson")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateFacePersonRequest::~CreateFacePersonRequest()
+{}
+
+long CreateFacePersonRequest::getFaceGroupId()const
+{
+	return faceGroupId_;
+}
+
+void CreateFacePersonRequest::setFaceGroupId(long faceGroupId)
+{
+	faceGroupId_ = faceGroupId;
+	setParameter("FaceGroupId", std::to_string(faceGroupId));
+}
+
+std::string CreateFacePersonRequest::getImageUrls()const
+{
+	return imageUrls_;
+}
+
+void CreateFacePersonRequest::setImageUrls(const std::string& imageUrls)
+{
+	imageUrls_ = imageUrls;
+	setParameter("ImageUrls", imageUrls);
+}
+
+std::string CreateFacePersonRequest::getFacePersonName()const
+{
+	return facePersonName_;
+}
+
+void CreateFacePersonRequest::setFacePersonName(const std::string& facePersonName)
+{
+	facePersonName_ = facePersonName;
+	setParameter("FacePersonName", facePersonName);
+}
+

multimediaai/src/model/CreateFacePersonResult.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/multimediaai/model/CreateFacePersonResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+CreateFacePersonResult::CreateFacePersonResult() :
+	ServiceResult()
+{}
+
+CreateFacePersonResult::CreateFacePersonResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateFacePersonResult::~CreateFacePersonResult()
+{}
+
+void CreateFacePersonResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["FacePersonId"].isNull())
+		facePersonId_ = std::stol(value["FacePersonId"].asString());
+
+}
+
+long CreateFacePersonResult::getFacePersonId()const
+{
+	return facePersonId_;
+}
+

multimediaai/src/model/CreateGifTaskRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/multimediaai/model/CreateGifTaskRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::CreateGifTaskRequest;
+
+CreateGifTaskRequest::CreateGifTaskRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "CreateGifTask")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateGifTaskRequest::~CreateGifTaskRequest()
+{}
+
+long CreateGifTaskRequest::getTemplateId()const
+{
+	return templateId_;
+}
+
+void CreateGifTaskRequest::setTemplateId(long templateId)
+{
+	templateId_ = templateId;
+	setParameter("TemplateId", std::to_string(templateId));
+}
+
+std::string CreateGifTaskRequest::getVideoUrl()const
+{
+	return videoUrl_;
+}
+
+void CreateGifTaskRequest::setVideoUrl(const std::string& videoUrl)
+{
+	videoUrl_ = videoUrl;
+	setParameter("VideoUrl", videoUrl);
+}
+
+std::string CreateGifTaskRequest::getVideoName()const
+{
+	return videoName_;
+}
+
+void CreateGifTaskRequest::setVideoName(const std::string& videoName)
+{
+	videoName_ = videoName;
+	setParameter("VideoName", videoName);
+}
+
+std::string CreateGifTaskRequest::getCallbackUrl()const
+{
+	return callbackUrl_;
+}
+
+void CreateGifTaskRequest::setCallbackUrl(const std::string& callbackUrl)
+{
+	callbackUrl_ = callbackUrl;
+	setParameter("CallbackUrl", callbackUrl);
+}
+
+std::string CreateGifTaskRequest::getApplicationId()const
+{
+	return applicationId_;
+}
+
+void CreateGifTaskRequest::setApplicationId(const std::string& applicationId)
+{
+	applicationId_ = applicationId;
+	setParameter("ApplicationId", applicationId);
+}
+

multimediaai/src/model/CreateGifTaskResult.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/multimediaai/model/CreateGifTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+CreateGifTaskResult::CreateGifTaskResult() :
+	ServiceResult()
+{}
+
+CreateGifTaskResult::CreateGifTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateGifTaskResult::~CreateGifTaskResult()
+{}
+
+void CreateGifTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = std::stol(value["TaskId"].asString());
+
+}
+
+long CreateGifTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+

multimediaai/src/model/CreateLabelTaskRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/multimediaai/model/CreateLabelTaskRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::CreateLabelTaskRequest;
+
+CreateLabelTaskRequest::CreateLabelTaskRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "CreateLabelTask")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateLabelTaskRequest::~CreateLabelTaskRequest()
+{}
+
+long CreateLabelTaskRequest::getTemplateId()const
+{
+	return templateId_;
+}
+
+void CreateLabelTaskRequest::setTemplateId(long templateId)
+{
+	templateId_ = templateId;
+	setParameter("TemplateId", std::to_string(templateId));
+}
+
+std::string CreateLabelTaskRequest::getVideoUrl()const
+{
+	return videoUrl_;
+}
+
+void CreateLabelTaskRequest::setVideoUrl(const std::string& videoUrl)
+{
+	videoUrl_ = videoUrl;
+	setParameter("VideoUrl", videoUrl);
+}
+
+std::string CreateLabelTaskRequest::getVideoName()const
+{
+	return videoName_;
+}
+
+void CreateLabelTaskRequest::setVideoName(const std::string& videoName)
+{
+	videoName_ = videoName;
+	setParameter("VideoName", videoName);
+}
+
+std::string CreateLabelTaskRequest::getCallbackUrl()const
+{
+	return callbackUrl_;
+}
+
+void CreateLabelTaskRequest::setCallbackUrl(const std::string& callbackUrl)
+{
+	callbackUrl_ = callbackUrl;
+	setParameter("CallbackUrl", callbackUrl);
+}
+
+std::string CreateLabelTaskRequest::getApplicationId()const
+{
+	return applicationId_;
+}
+
+void CreateLabelTaskRequest::setApplicationId(const std::string& applicationId)
+{
+	applicationId_ = applicationId;
+	setParameter("ApplicationId", applicationId);
+}
+

multimediaai/src/model/CreateLabelTaskResult.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/multimediaai/model/CreateLabelTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+CreateLabelTaskResult::CreateLabelTaskResult() :
+	ServiceResult()
+{}
+
+CreateLabelTaskResult::CreateLabelTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateLabelTaskResult::~CreateLabelTaskResult()
+{}
+
+void CreateLabelTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = std::stol(value["TaskId"].asString());
+
+}
+
+long CreateLabelTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+

multimediaai/src/model/DeleteFaceGroupRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/multimediaai/model/DeleteFaceGroupRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::DeleteFaceGroupRequest;
+
+DeleteFaceGroupRequest::DeleteFaceGroupRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "DeleteFaceGroup")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteFaceGroupRequest::~DeleteFaceGroupRequest()
+{}
+
+long DeleteFaceGroupRequest::getFaceGroupId()const
+{
+	return faceGroupId_;
+}
+
+void DeleteFaceGroupRequest::setFaceGroupId(long faceGroupId)
+{
+	faceGroupId_ = faceGroupId;
+	setParameter("FaceGroupId", std::to_string(faceGroupId));
+}
+

multimediaai/src/model/DeleteFaceGroupResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/multimediaai/model/DeleteFaceGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+DeleteFaceGroupResult::DeleteFaceGroupResult() :
+	ServiceResult()
+{}
+
+DeleteFaceGroupResult::DeleteFaceGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteFaceGroupResult::~DeleteFaceGroupResult()
+{}
+
+void DeleteFaceGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

multimediaai/src/model/DeleteFaceImageRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * 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/multimediaai/model/DeleteFaceImageRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::DeleteFaceImageRequest;
+
+DeleteFaceImageRequest::DeleteFaceImageRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "DeleteFaceImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteFaceImageRequest::~DeleteFaceImageRequest()
+{}
+
+long DeleteFaceImageRequest::getFaceGroupId()const
+{
+	return faceGroupId_;
+}
+
+void DeleteFaceImageRequest::setFaceGroupId(long faceGroupId)
+{
+	faceGroupId_ = faceGroupId;
+	setParameter("FaceGroupId", std::to_string(faceGroupId));
+}
+
+long DeleteFaceImageRequest::getFacePersonId()const
+{
+	return facePersonId_;
+}
+
+void DeleteFaceImageRequest::setFacePersonId(long facePersonId)
+{
+	facePersonId_ = facePersonId;
+	setParameter("FacePersonId", std::to_string(facePersonId));
+}
+
+long DeleteFaceImageRequest::getFaceImageId()const
+{
+	return faceImageId_;
+}
+
+void DeleteFaceImageRequest::setFaceImageId(long faceImageId)
+{
+	faceImageId_ = faceImageId;
+	setParameter("FaceImageId", std::to_string(faceImageId));
+}
+

multimediaai/src/model/DeleteFaceImageResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/multimediaai/model/DeleteFaceImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+DeleteFaceImageResult::DeleteFaceImageResult() :
+	ServiceResult()
+{}
+
+DeleteFaceImageResult::DeleteFaceImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteFaceImageResult::~DeleteFaceImageResult()
+{}
+
+void DeleteFaceImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

multimediaai/src/model/DeleteFacePersonRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/multimediaai/model/DeleteFacePersonRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::DeleteFacePersonRequest;
+
+DeleteFacePersonRequest::DeleteFacePersonRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "DeleteFacePerson")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteFacePersonRequest::~DeleteFacePersonRequest()
+{}
+
+long DeleteFacePersonRequest::getFaceGroupId()const
+{
+	return faceGroupId_;
+}
+
+void DeleteFacePersonRequest::setFaceGroupId(long faceGroupId)
+{
+	faceGroupId_ = faceGroupId;
+	setParameter("FaceGroupId", std::to_string(faceGroupId));
+}
+
+long DeleteFacePersonRequest::getFacePersonId()const
+{
+	return facePersonId_;
+}
+
+void DeleteFacePersonRequest::setFacePersonId(long facePersonId)
+{
+	facePersonId_ = facePersonId;
+	setParameter("FacePersonId", std::to_string(facePersonId));
+}
+

multimediaai/src/model/DeleteFacePersonResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/multimediaai/model/DeleteFacePersonResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+DeleteFacePersonResult::DeleteFacePersonResult() :
+	ServiceResult()
+{}
+
+DeleteFacePersonResult::DeleteFacePersonResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteFacePersonResult::~DeleteFacePersonResult()
+{}
+
+void DeleteFacePersonResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

multimediaai/src/model/GetTaskResultRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/multimediaai/model/GetTaskResultRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::GetTaskResultRequest;
+
+GetTaskResultRequest::GetTaskResultRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "GetTaskResult")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetTaskResultRequest::~GetTaskResultRequest()
+{}
+
+long GetTaskResultRequest::getTaskId()const
+{
+	return taskId_;
+}
+
+void GetTaskResultRequest::setTaskId(long taskId)
+{
+	taskId_ = taskId;
+	setParameter("TaskId", std::to_string(taskId));
+}
+

multimediaai/src/model/GetTaskResultResult.cc

@@ -0,0 +1,75 @@
+/*
+ * 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/multimediaai/model/GetTaskResultResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+GetTaskResultResult::GetTaskResultResult() :
+	ServiceResult()
+{}
+
+GetTaskResultResult::GetTaskResultResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetTaskResultResult::~GetTaskResultResult()
+{}
+
+void GetTaskResultResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	if(!resultNode["ApplicationId"].isNull())
+		result_.applicationId = resultNode["ApplicationId"].asString();
+	if(!resultNode["VideoName"].isNull())
+		result_.videoName = resultNode["VideoName"].asString();
+	if(!resultNode["ProcessResultUrl"].isNull())
+		result_.processResultUrl = resultNode["ProcessResultUrl"].asString();
+	if(!resultNode["AnalysisUseTime"].isNull())
+		result_.analysisUseTime = std::stol(resultNode["AnalysisUseTime"].asString());
+	if(!resultNode["VideoUrl"].isNull())
+		result_.videoUrl = resultNode["VideoUrl"].asString();
+	if(!resultNode["ErrorName"].isNull())
+		result_.errorName = resultNode["ErrorName"].asString();
+	if(!resultNode["ErrorReason"].isNull())
+		result_.errorReason = resultNode["ErrorReason"].asString();
+	if(!resultNode["ErrorCode"].isNull())
+		result_.errorCode = resultNode["ErrorCode"].asString();
+	if(!resultNode["ErrorMessage"].isNull())
+		result_.errorMessage = resultNode["ErrorMessage"].asString();
+	if(!value["Status"].isNull())
+		status_ = std::stoi(value["Status"].asString());
+
+}
+
+int GetTaskResultResult::getStatus()const
+{
+	return status_;
+}
+
+GetTaskResultResult::Result GetTaskResultResult::getResult()const
+{
+	return result_;
+}
+

multimediaai/src/model/GetTaskStatusRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/multimediaai/model/GetTaskStatusRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::GetTaskStatusRequest;
+
+GetTaskStatusRequest::GetTaskStatusRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "GetTaskStatus")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetTaskStatusRequest::~GetTaskStatusRequest()
+{}
+
+long GetTaskStatusRequest::getTaskId()const
+{
+	return taskId_;
+}
+
+void GetTaskStatusRequest::setTaskId(long taskId)
+{
+	taskId_ = taskId;
+	setParameter("TaskId", std::to_string(taskId));
+}
+

multimediaai/src/model/GetTaskStatusResult.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/multimediaai/model/GetTaskStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+GetTaskStatusResult::GetTaskStatusResult() :
+	ServiceResult()
+{}
+
+GetTaskStatusResult::GetTaskStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetTaskStatusResult::~GetTaskStatusResult()
+{}
+
+void GetTaskStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Status"].isNull())
+		status_ = std::stoi(value["Status"].asString());
+
+}
+
+int GetTaskStatusResult::getStatus()const
+{
+	return status_;
+}
+

multimediaai/src/model/ListFaceGroupsRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/multimediaai/model/ListFaceGroupsRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ListFaceGroupsRequest;
+
+ListFaceGroupsRequest::ListFaceGroupsRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ListFaceGroups")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListFaceGroupsRequest::~ListFaceGroupsRequest()
+{}
+
+int ListFaceGroupsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListFaceGroupsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+int ListFaceGroupsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListFaceGroupsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

multimediaai/src/model/ListFaceGroupsResult.cc

@@ -0,0 +1,96 @@
+/*
+ * 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/multimediaai/model/ListFaceGroupsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ListFaceGroupsResult::ListFaceGroupsResult() :
+	ServiceResult()
+{}
+
+ListFaceGroupsResult::ListFaceGroupsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListFaceGroupsResult::~ListFaceGroupsResult()
+{}
+
+void ListFaceGroupsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFaceGroupsNode = value["FaceGroups"]["FaceGroup"];
+	for (auto valueFaceGroupsFaceGroup : allFaceGroupsNode)
+	{
+		FaceGroup faceGroupsObject;
+		if(!valueFaceGroupsFaceGroup["FaceGroupId"].isNull())
+			faceGroupsObject.faceGroupId = std::stol(valueFaceGroupsFaceGroup["FaceGroupId"].asString());
+		if(!valueFaceGroupsFaceGroup["FaceGroupName"].isNull())
+			faceGroupsObject.faceGroupName = valueFaceGroupsFaceGroup["FaceGroupName"].asString();
+		if(!valueFaceGroupsFaceGroup["Description"].isNull())
+			faceGroupsObject.description = valueFaceGroupsFaceGroup["Description"].asString();
+		if(!valueFaceGroupsFaceGroup["PersonCount"].isNull())
+			faceGroupsObject.personCount = std::stol(valueFaceGroupsFaceGroup["PersonCount"].asString());
+		if(!valueFaceGroupsFaceGroup["ImageCount"].isNull())
+			faceGroupsObject.imageCount = std::stol(valueFaceGroupsFaceGroup["ImageCount"].asString());
+		auto allTemplatesNode = allFaceGroupsNode["Templates"]["TemplatesItem"];
+		for (auto allFaceGroupsNodeTemplatesTemplatesItem : allTemplatesNode)
+		{
+			FaceGroup::TemplatesItem templatesObject;
+			if(!allFaceGroupsNodeTemplatesTemplatesItem["Id"].isNull())
+				templatesObject.id = allFaceGroupsNodeTemplatesTemplatesItem["Id"].asString();
+			if(!allFaceGroupsNodeTemplatesTemplatesItem["Name"].isNull())
+				templatesObject.name = allFaceGroupsNodeTemplatesTemplatesItem["Name"].asString();
+			faceGroupsObject.templates.push_back(templatesObject);
+		}
+		faceGroups_.push_back(faceGroupsObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+
+}
+
+long ListFaceGroupsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListFaceGroupsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListFaceGroupsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListFaceGroupsResult::FaceGroup> ListFaceGroupsResult::getFaceGroups()const
+{
+	return faceGroups_;
+}
+

multimediaai/src/model/ListFaceImagesRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * 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/multimediaai/model/ListFaceImagesRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ListFaceImagesRequest;
+
+ListFaceImagesRequest::ListFaceImagesRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ListFaceImages")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListFaceImagesRequest::~ListFaceImagesRequest()
+{}
+
+long ListFaceImagesRequest::getFaceGroupId()const
+{
+	return faceGroupId_;
+}
+
+void ListFaceImagesRequest::setFaceGroupId(long faceGroupId)
+{
+	faceGroupId_ = faceGroupId;
+	setParameter("FaceGroupId", std::to_string(faceGroupId));
+}
+
+long ListFaceImagesRequest::getFacePersonId()const
+{
+	return facePersonId_;
+}
+
+void ListFaceImagesRequest::setFacePersonId(long facePersonId)
+{
+	facePersonId_ = facePersonId;
+	setParameter("FacePersonId", std::to_string(facePersonId));
+}
+
+int ListFaceImagesRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListFaceImagesRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+int ListFaceImagesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListFaceImagesRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

multimediaai/src/model/ListFaceImagesResult.cc

@@ -0,0 +1,83 @@
+/*
+ * 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/multimediaai/model/ListFaceImagesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ListFaceImagesResult::ListFaceImagesResult() :
+	ServiceResult()
+{}
+
+ListFaceImagesResult::ListFaceImagesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListFaceImagesResult::~ListFaceImagesResult()
+{}
+
+void ListFaceImagesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFaceImagesNode = value["FaceImages"]["FaceImage"];
+	for (auto valueFaceImagesFaceImage : allFaceImagesNode)
+	{
+		FaceImage faceImagesObject;
+		if(!valueFaceImagesFaceImage["FaceImageId"].isNull())
+			faceImagesObject.faceImageId = std::stol(valueFaceImagesFaceImage["FaceImageId"].asString());
+		if(!valueFaceImagesFaceImage["ImageUrl"].isNull())
+			faceImagesObject.imageUrl = valueFaceImagesFaceImage["ImageUrl"].asString();
+		auto allFaceRectangle = value["FaceRectangle"]["FaceRectangle"];
+		for (auto value : allFaceRectangle)
+			faceImagesObject.faceRectangle.push_back(value.asString());
+		faceImages_.push_back(faceImagesObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+
+}
+
+long ListFaceImagesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListFaceImagesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListFaceImagesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListFaceImagesResult::FaceImage> ListFaceImagesResult::getFaceImages()const
+{
+	return faceImages_;
+}
+

multimediaai/src/model/ListFacePersonsRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * 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/multimediaai/model/ListFacePersonsRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ListFacePersonsRequest;
+
+ListFacePersonsRequest::ListFacePersonsRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ListFacePersons")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListFacePersonsRequest::~ListFacePersonsRequest()
+{}
+
+long ListFacePersonsRequest::getFaceGroupId()const
+{
+	return faceGroupId_;
+}
+
+void ListFacePersonsRequest::setFaceGroupId(long faceGroupId)
+{
+	faceGroupId_ = faceGroupId;
+	setParameter("FaceGroupId", std::to_string(faceGroupId));
+}
+
+std::string ListFacePersonsRequest::getFacePersonName()const
+{
+	return facePersonName_;
+}
+
+void ListFacePersonsRequest::setFacePersonName(const std::string& facePersonName)
+{
+	facePersonName_ = facePersonName;
+	setParameter("FacePersonName", facePersonName);
+}
+
+int ListFacePersonsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListFacePersonsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+int ListFacePersonsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListFacePersonsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

multimediaai/src/model/ListFacePersonsResult.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/multimediaai/model/ListFacePersonsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ListFacePersonsResult::ListFacePersonsResult() :
+	ServiceResult()
+{}
+
+ListFacePersonsResult::ListFacePersonsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListFacePersonsResult::~ListFacePersonsResult()
+{}
+
+void ListFacePersonsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFacePersonsNode = value["FacePersons"]["FacePerson"];
+	for (auto valueFacePersonsFacePerson : allFacePersonsNode)
+	{
+		FacePerson facePersonsObject;
+		if(!valueFacePersonsFacePerson["FacePersonId"].isNull())
+			facePersonsObject.facePersonId = std::stol(valueFacePersonsFacePerson["FacePersonId"].asString());
+		if(!valueFacePersonsFacePerson["FacePersonName"].isNull())
+			facePersonsObject.facePersonName = valueFacePersonsFacePerson["FacePersonName"].asString();
+		if(!valueFacePersonsFacePerson["ImageUrl"].isNull())
+			facePersonsObject.imageUrl = valueFacePersonsFacePerson["ImageUrl"].asString();
+		if(!valueFacePersonsFacePerson["ImageCount"].isNull())
+			facePersonsObject.imageCount = std::stol(valueFacePersonsFacePerson["ImageCount"].asString());
+		facePersons_.push_back(facePersonsObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+
+}
+
+long ListFacePersonsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<ListFacePersonsResult::FacePerson> ListFacePersonsResult::getFacePersons()const
+{
+	return facePersons_;
+}
+
+int ListFacePersonsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListFacePersonsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

multimediaai/src/model/RegisterFaceImageRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * 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/multimediaai/model/RegisterFaceImageRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::RegisterFaceImageRequest;
+
+RegisterFaceImageRequest::RegisterFaceImageRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "RegisterFaceImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RegisterFaceImageRequest::~RegisterFaceImageRequest()
+{}
+
+long RegisterFaceImageRequest::getFaceGroupId()const
+{
+	return faceGroupId_;
+}
+
+void RegisterFaceImageRequest::setFaceGroupId(long faceGroupId)
+{
+	faceGroupId_ = faceGroupId;
+	setParameter("FaceGroupId", std::to_string(faceGroupId));
+}
+
+long RegisterFaceImageRequest::getFacePersonId()const
+{
+	return facePersonId_;
+}
+
+void RegisterFaceImageRequest::setFacePersonId(long facePersonId)
+{
+	facePersonId_ = facePersonId;
+	setParameter("FacePersonId", std::to_string(facePersonId));
+}
+
+std::string RegisterFaceImageRequest::getImageUrl()const
+{
+	return imageUrl_;
+}
+
+void RegisterFaceImageRequest::setImageUrl(const std::string& imageUrl)
+{
+	imageUrl_ = imageUrl;
+	setParameter("ImageUrl", imageUrl);
+}
+

multimediaai/src/model/RegisterFaceImageResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/multimediaai/model/RegisterFaceImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+RegisterFaceImageResult::RegisterFaceImageResult() :
+	ServiceResult()
+{}
+
+RegisterFaceImageResult::RegisterFaceImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RegisterFaceImageResult::~RegisterFaceImageResult()
+{}
+
+void RegisterFaceImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+