Add Body Detection and Image Splicing API.

imm/src/model/AddStoryFilesRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/imm/model/AddStoryFilesRequest.h>
+
+using AlibabaCloud::Imm::Model::AddStoryFilesRequest;
+
+AddStoryFilesRequest::AddStoryFilesRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "AddStoryFiles") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddStoryFilesRequest::~AddStoryFilesRequest() {}
+
+std::string AddStoryFilesRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void AddStoryFilesRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setBodyParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string AddStoryFilesRequest::getProjectName() const {
+  return projectName_;
+}
+
+void AddStoryFilesRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setBodyParameter(std::string("ProjectName"), projectName);
+}
+
+std::vector<AddStoryFilesRequest::Files> AddStoryFilesRequest::getFiles() const {
+  return files_;
+}
+
+void AddStoryFilesRequest::setFiles(const std::vector<AddStoryFilesRequest::Files> &files) {
+  files_ = files;
+  for(int dep1 = 0; dep1 != files.size(); dep1++) {
+    setBodyParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".URI", files[dep1].uRI);
+  }
+}
+
+std::string AddStoryFilesRequest::getObjectId() const {
+  return objectId_;
+}
+
+void AddStoryFilesRequest::setObjectId(const std::string &objectId) {
+  objectId_ = objectId;
+  setBodyParameter(std::string("ObjectId"), objectId);
+}
+

imm/src/model/AddStoryFilesResult.cc

@@ -14,45 +14,48 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/GetContentKeyResult.h>
+#include <alibabacloud/imm/model/AddStoryFilesResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-GetContentKeyResult::GetContentKeyResult() :
+AddStoryFilesResult::AddStoryFilesResult() :
 	ServiceResult()
 {}
 
-GetContentKeyResult::GetContentKeyResult(const std::string &payload) :
+AddStoryFilesResult::AddStoryFilesResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-GetContentKeyResult::~GetContentKeyResult()
+AddStoryFilesResult::~AddStoryFilesResult()
 {}
 
-void GetContentKeyResult::parse(const std::string &payload)
+void AddStoryFilesResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["VersionId"].isNull())
-		versionId_ = value["VersionId"].asString();
-	if(!value["KeyInfos"].isNull())
-		keyInfos_ = value["KeyInfos"].asString();
+	auto allFilesNode = value["Files"]["FilesItem"];
+	for (auto valueFilesFilesItem : allFilesNode)
+	{
+		FilesItem filesObject;
+		if(!valueFilesFilesItem["URI"].isNull())
+			filesObject.uRI = valueFilesFilesItem["URI"].asString();
+		if(!valueFilesFilesItem["ErrorCode"].isNull())
+			filesObject.errorCode = valueFilesFilesItem["ErrorCode"].asString();
+		if(!valueFilesFilesItem["ErrorMessage"].isNull())
+			filesObject.errorMessage = valueFilesFilesItem["ErrorMessage"].asString();
+		files_.push_back(filesObject);
+	}
 
 }
 
-std::string GetContentKeyResult::getVersionId()const
+std::vector<AddStoryFilesResult::FilesItem> AddStoryFilesResult::getFiles()const
 {
-	return versionId_;
-}
-
-std::string GetContentKeyResult::getKeyInfos()const
-{
-	return keyInfos_;
+	return files_;
 }
 

imm/src/model/AttachOSSBucketRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/AttachOSSBucketRequest.h>
+
+using AlibabaCloud::Imm::Model::AttachOSSBucketRequest;
+
+AttachOSSBucketRequest::AttachOSSBucketRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "AttachOSSBucket") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AttachOSSBucketRequest::~AttachOSSBucketRequest() {}
+
+std::string AttachOSSBucketRequest::getProjectName() const {
+  return projectName_;
+}
+
+void AttachOSSBucketRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string AttachOSSBucketRequest::getOSSBucket() const {
+  return oSSBucket_;
+}
+
+void AttachOSSBucketRequest::setOSSBucket(const std::string &oSSBucket) {
+  oSSBucket_ = oSSBucket;
+  setParameter(std::string("OSSBucket"), oSSBucket);
+}
+

imm/src/model/AttachOSSBucketResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/DeleteVideoTaskResult.h>
+#include <alibabacloud/imm/model/AttachOSSBucketResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-DeleteVideoTaskResult::DeleteVideoTaskResult() :
+AttachOSSBucketResult::AttachOSSBucketResult() :
 	ServiceResult()
 {}
 
-DeleteVideoTaskResult::DeleteVideoTaskResult(const std::string &payload) :
+AttachOSSBucketResult::AttachOSSBucketResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteVideoTaskResult::~DeleteVideoTaskResult()
+AttachOSSBucketResult::~AttachOSSBucketResult()
 {}
 
-void DeleteVideoTaskResult::parse(const std::string &payload)
+void AttachOSSBucketResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

imm/src/model/BatchDeleteFileMetaRequest.cc

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/BatchDeleteFileMetaRequest.h>
+
+using AlibabaCloud::Imm::Model::BatchDeleteFileMetaRequest;
+
+BatchDeleteFileMetaRequest::BatchDeleteFileMetaRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "BatchDeleteFileMeta") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+BatchDeleteFileMetaRequest::~BatchDeleteFileMetaRequest() {}
+
+std::string BatchDeleteFileMetaRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void BatchDeleteFileMetaRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string BatchDeleteFileMetaRequest::getProjectName() const {
+  return projectName_;
+}
+
+void BatchDeleteFileMetaRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::vector<BatchDeleteFileMetaRequest::std::string> BatchDeleteFileMetaRequest::getURIs() const {
+  return uRIs_;
+}
+
+void BatchDeleteFileMetaRequest::setURIs(const std::vector<BatchDeleteFileMetaRequest::std::string> &uRIs) {
+  uRIs_ = uRIs;
+  for(int dep1 = 0; dep1 != uRIs.size(); dep1++) {
+    setParameter(std::string("URIs") + "." + std::to_string(dep1 + 1), uRIs[dep1]);
+  }
+}
+

imm/src/model/BatchDeleteFileMetaResult.cc

@@ -14,38 +14,31 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/DeleteSetResult.h>
+#include <alibabacloud/imm/model/BatchDeleteFileMetaResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-DeleteSetResult::DeleteSetResult() :
+BatchDeleteFileMetaResult::BatchDeleteFileMetaResult() :
 	ServiceResult()
 {}
 
-DeleteSetResult::DeleteSetResult(const std::string &payload) :
+BatchDeleteFileMetaResult::BatchDeleteFileMetaResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteSetResult::~DeleteSetResult()
+BatchDeleteFileMetaResult::~BatchDeleteFileMetaResult()
 {}
 
-void DeleteSetResult::parse(const std::string &payload)
+void BatchDeleteFileMetaResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["SetId"].isNull())
-		setId_ = value["SetId"].asString();
 
 }
 
-std::string DeleteSetResult::getSetId()const
-{
-	return setId_;
-}
-

imm/src/model/BatchGetFileMetaRequest.cc

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/BatchGetFileMetaRequest.h>
+
+using AlibabaCloud::Imm::Model::BatchGetFileMetaRequest;
+
+BatchGetFileMetaRequest::BatchGetFileMetaRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "BatchGetFileMeta") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+BatchGetFileMetaRequest::~BatchGetFileMetaRequest() {}
+
+std::string BatchGetFileMetaRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void BatchGetFileMetaRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string BatchGetFileMetaRequest::getProjectName() const {
+  return projectName_;
+}
+
+void BatchGetFileMetaRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::vector<BatchGetFileMetaRequest::std::string> BatchGetFileMetaRequest::getURIs() const {
+  return uRIs_;
+}
+
+void BatchGetFileMetaRequest::setURIs(const std::vector<BatchGetFileMetaRequest::std::string> &uRIs) {
+  uRIs_ = uRIs;
+  for(int dep1 = 0; dep1 != uRIs.size(); dep1++) {
+    setParameter(std::string("URIs") + "." + std::to_string(dep1 + 1), uRIs[dep1]);
+  }
+}
+

imm/src/model/BatchGetFileMetaResult.cc

@@ -0,0 +1,531 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/BatchGetFileMetaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+BatchGetFileMetaResult::BatchGetFileMetaResult() :
+	ServiceResult()
+{}
+
+BatchGetFileMetaResult::BatchGetFileMetaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+BatchGetFileMetaResult::~BatchGetFileMetaResult()
+{}
+
+void BatchGetFileMetaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFilesNode = value["Files"]["FilesItem"];
+	for (auto valueFilesFilesItem : allFilesNode)
+	{
+		FilesItem filesObject;
+		if(!valueFilesFilesItem["OwnerId"].isNull())
+			filesObject.ownerId = valueFilesFilesItem["OwnerId"].asString();
+		if(!valueFilesFilesItem["ProjectName"].isNull())
+			filesObject.projectName = valueFilesFilesItem["ProjectName"].asString();
+		if(!valueFilesFilesItem["DatasetName"].isNull())
+			filesObject.datasetName = valueFilesFilesItem["DatasetName"].asString();
+		if(!valueFilesFilesItem["ObjectType"].isNull())
+			filesObject.objectType = valueFilesFilesItem["ObjectType"].asString();
+		if(!valueFilesFilesItem["ObjectId"].isNull())
+			filesObject.objectId = valueFilesFilesItem["ObjectId"].asString();
+		if(!valueFilesFilesItem["UpdateTime"].isNull())
+			filesObject.updateTime = valueFilesFilesItem["UpdateTime"].asString();
+		if(!valueFilesFilesItem["CreateTime"].isNull())
+			filesObject.createTime = valueFilesFilesItem["CreateTime"].asString();
+		if(!valueFilesFilesItem["URI"].isNull())
+			filesObject.uRI = valueFilesFilesItem["URI"].asString();
+		if(!valueFilesFilesItem["OSSURI"].isNull())
+			filesObject.oSSURI = valueFilesFilesItem["OSSURI"].asString();
+		if(!valueFilesFilesItem["Filename"].isNull())
+			filesObject.filename = valueFilesFilesItem["Filename"].asString();
+		if(!valueFilesFilesItem["MediaType"].isNull())
+			filesObject.mediaType = valueFilesFilesItem["MediaType"].asString();
+		if(!valueFilesFilesItem["ContentType"].isNull())
+			filesObject.contentType = valueFilesFilesItem["ContentType"].asString();
+		if(!valueFilesFilesItem["Size"].isNull())
+			filesObject.size = std::stol(valueFilesFilesItem["Size"].asString());
+		if(!valueFilesFilesItem["FileHash"].isNull())
+			filesObject.fileHash = valueFilesFilesItem["FileHash"].asString();
+		if(!valueFilesFilesItem["FileModifiedTime"].isNull())
+			filesObject.fileModifiedTime = valueFilesFilesItem["FileModifiedTime"].asString();
+		if(!valueFilesFilesItem["FileCreateTime"].isNull())
+			filesObject.fileCreateTime = valueFilesFilesItem["FileCreateTime"].asString();
+		if(!valueFilesFilesItem["FileAccessTime"].isNull())
+			filesObject.fileAccessTime = valueFilesFilesItem["FileAccessTime"].asString();
+		if(!valueFilesFilesItem["ProduceTime"].isNull())
+			filesObject.produceTime = valueFilesFilesItem["ProduceTime"].asString();
+		if(!valueFilesFilesItem["LatLong"].isNull())
+			filesObject.latLong = valueFilesFilesItem["LatLong"].asString();
+		if(!valueFilesFilesItem["Timezone"].isNull())
+			filesObject.timezone = valueFilesFilesItem["Timezone"].asString();
+		if(!valueFilesFilesItem["TravelClusterId"].isNull())
+			filesObject.travelClusterId = valueFilesFilesItem["TravelClusterId"].asString();
+		if(!valueFilesFilesItem["Orientation"].isNull())
+			filesObject.orientation = std::stol(valueFilesFilesItem["Orientation"].asString());
+		if(!valueFilesFilesItem["FigureCount"].isNull())
+			filesObject.figureCount = std::stol(valueFilesFilesItem["FigureCount"].asString());
+		if(!valueFilesFilesItem["Title"].isNull())
+			filesObject.title = valueFilesFilesItem["Title"].asString();
+		if(!valueFilesFilesItem["ImageWidth"].isNull())
+			filesObject.imageWidth = std::stol(valueFilesFilesItem["ImageWidth"].asString());
+		if(!valueFilesFilesItem["ImageHeight"].isNull())
+			filesObject.imageHeight = std::stol(valueFilesFilesItem["ImageHeight"].asString());
+		if(!valueFilesFilesItem["EXIF"].isNull())
+			filesObject.eXIF = valueFilesFilesItem["EXIF"].asString();
+		if(!valueFilesFilesItem["VideoWidth"].isNull())
+			filesObject.videoWidth = std::stol(valueFilesFilesItem["VideoWidth"].asString());
+		if(!valueFilesFilesItem["VideoHeight"].isNull())
+			filesObject.videoHeight = std::stol(valueFilesFilesItem["VideoHeight"].asString());
+		if(!valueFilesFilesItem["Artist"].isNull())
+			filesObject.artist = valueFilesFilesItem["Artist"].asString();
+		if(!valueFilesFilesItem["AlbumArtist"].isNull())
+			filesObject.albumArtist = valueFilesFilesItem["AlbumArtist"].asString();
+		if(!valueFilesFilesItem["Composer"].isNull())
+			filesObject.composer = valueFilesFilesItem["Composer"].asString();
+		if(!valueFilesFilesItem["Performer"].isNull())
+			filesObject.performer = valueFilesFilesItem["Performer"].asString();
+		if(!valueFilesFilesItem["Language"].isNull())
+			filesObject.language = valueFilesFilesItem["Language"].asString();
+		if(!valueFilesFilesItem["Album"].isNull())
+			filesObject.album = valueFilesFilesItem["Album"].asString();
+		if(!valueFilesFilesItem["DocumentLanguage"].isNull())
+			filesObject.documentLanguage = valueFilesFilesItem["DocumentLanguage"].asString();
+		if(!valueFilesFilesItem["PageCount"].isNull())
+			filesObject.pageCount = std::stol(valueFilesFilesItem["PageCount"].asString());
+		if(!valueFilesFilesItem["DocumentContent"].isNull())
+			filesObject.documentContent = valueFilesFilesItem["DocumentContent"].asString();
+		if(!valueFilesFilesItem["ETag"].isNull())
+			filesObject.eTag = valueFilesFilesItem["ETag"].asString();
+		if(!valueFilesFilesItem["CacheControl"].isNull())
+			filesObject.cacheControl = valueFilesFilesItem["CacheControl"].asString();
+		if(!valueFilesFilesItem["ContentDisposition"].isNull())
+			filesObject.contentDisposition = valueFilesFilesItem["ContentDisposition"].asString();
+		if(!valueFilesFilesItem["ContentEncoding"].isNull())
+			filesObject.contentEncoding = valueFilesFilesItem["ContentEncoding"].asString();
+		if(!valueFilesFilesItem["ContentLanguage"].isNull())
+			filesObject.contentLanguage = valueFilesFilesItem["ContentLanguage"].asString();
+		if(!valueFilesFilesItem["AccessControlAllowOrigin"].isNull())
+			filesObject.accessControlAllowOrigin = valueFilesFilesItem["AccessControlAllowOrigin"].asString();
+		if(!valueFilesFilesItem["AccessControlRequestMethod"].isNull())
+			filesObject.accessControlRequestMethod = valueFilesFilesItem["AccessControlRequestMethod"].asString();
+		if(!valueFilesFilesItem["ServerSideEncryptionCustomerAlgorithm"].isNull())
+			filesObject.serverSideEncryptionCustomerAlgorithm = valueFilesFilesItem["ServerSideEncryptionCustomerAlgorithm"].asString();
+		if(!valueFilesFilesItem["ServerSideEncryption"].isNull())
+			filesObject.serverSideEncryption = valueFilesFilesItem["ServerSideEncryption"].asString();
+		if(!valueFilesFilesItem["ServerSideDataEncryption"].isNull())
+			filesObject.serverSideDataEncryption = valueFilesFilesItem["ServerSideDataEncryption"].asString();
+		if(!valueFilesFilesItem["ServerSideEncryptionKeyId"].isNull())
+			filesObject.serverSideEncryptionKeyId = valueFilesFilesItem["ServerSideEncryptionKeyId"].asString();
+		if(!valueFilesFilesItem["OSSStorageClass"].isNull())
+			filesObject.oSSStorageClass = valueFilesFilesItem["OSSStorageClass"].asString();
+		if(!valueFilesFilesItem["OSSCRC64"].isNull())
+			filesObject.oSSCRC64 = valueFilesFilesItem["OSSCRC64"].asString();
+		if(!valueFilesFilesItem["ObjectACL"].isNull())
+			filesObject.objectACL = valueFilesFilesItem["ObjectACL"].asString();
+		if(!valueFilesFilesItem["ContentMd5"].isNull())
+			filesObject.contentMd5 = valueFilesFilesItem["ContentMd5"].asString();
+		if(!valueFilesFilesItem["OSSUserMeta"].isNull())
+			filesObject.oSSUserMeta = valueFilesFilesItem["OSSUserMeta"].asString();
+		if(!valueFilesFilesItem["OSSTaggingCount"].isNull())
+			filesObject.oSSTaggingCount = std::stol(valueFilesFilesItem["OSSTaggingCount"].asString());
+		if(!valueFilesFilesItem["OSSTagging"].isNull())
+			filesObject.oSSTagging = valueFilesFilesItem["OSSTagging"].asString();
+		if(!valueFilesFilesItem["OSSExpiration"].isNull())
+			filesObject.oSSExpiration = valueFilesFilesItem["OSSExpiration"].asString();
+		if(!valueFilesFilesItem["OSSVersionId"].isNull())
+			filesObject.oSSVersionId = valueFilesFilesItem["OSSVersionId"].asString();
+		if(!valueFilesFilesItem["OSSDeleteMarker"].isNull())
+			filesObject.oSSDeleteMarker = valueFilesFilesItem["OSSDeleteMarker"].asString();
+		if(!valueFilesFilesItem["OSSObjectType"].isNull())
+			filesObject.oSSObjectType = valueFilesFilesItem["OSSObjectType"].asString();
+		if(!valueFilesFilesItem["CustomId"].isNull())
+			filesObject.customId = valueFilesFilesItem["CustomId"].asString();
+		if(!valueFilesFilesItem["CustomLabels"].isNull())
+			filesObject.customLabels = valueFilesFilesItem["CustomLabels"].asString();
+		if(!valueFilesFilesItem["StreamCount"].isNull())
+			filesObject.streamCount = std::stol(valueFilesFilesItem["StreamCount"].asString());
+		if(!valueFilesFilesItem["ProgramCount"].isNull())
+			filesObject.programCount = std::stol(valueFilesFilesItem["ProgramCount"].asString());
+		if(!valueFilesFilesItem["FormatName"].isNull())
+			filesObject.formatName = valueFilesFilesItem["FormatName"].asString();
+		if(!valueFilesFilesItem["FormatLongName"].isNull())
+			filesObject.formatLongName = valueFilesFilesItem["FormatLongName"].asString();
+		if(!valueFilesFilesItem["StartTime"].isNull())
+			filesObject.startTime = valueFilesFilesItem["StartTime"].asString();
+		if(!valueFilesFilesItem["Bitrate"].isNull())
+			filesObject.bitrate = std::stol(valueFilesFilesItem["Bitrate"].asString());
+		if(!valueFilesFilesItem["Duration"].isNull())
+			filesObject.duration = valueFilesFilesItem["Duration"].asString();
+		auto allAddressesNode = valueFilesFilesItem["Addresses"]["AddressesItem"];
+		for (auto valueFilesFilesItemAddressesAddressesItem : allAddressesNode)
+		{
+			FilesItem::AddressesItem addressesObject;
+			if(!valueFilesFilesItemAddressesAddressesItem["Language"].isNull())
+				addressesObject.language = valueFilesFilesItemAddressesAddressesItem["Language"].asString();
+			if(!valueFilesFilesItemAddressesAddressesItem["AddressLine"].isNull())
+				addressesObject.addressLine = valueFilesFilesItemAddressesAddressesItem["AddressLine"].asString();
+			if(!valueFilesFilesItemAddressesAddressesItem["Country"].isNull())
+				addressesObject.country = valueFilesFilesItemAddressesAddressesItem["Country"].asString();
+			if(!valueFilesFilesItemAddressesAddressesItem["Province"].isNull())
+				addressesObject.province = valueFilesFilesItemAddressesAddressesItem["Province"].asString();
+			if(!valueFilesFilesItemAddressesAddressesItem["City"].isNull())
+				addressesObject.city = valueFilesFilesItemAddressesAddressesItem["City"].asString();
+			if(!valueFilesFilesItemAddressesAddressesItem["District"].isNull())
+				addressesObject.district = valueFilesFilesItemAddressesAddressesItem["District"].asString();
+			if(!valueFilesFilesItemAddressesAddressesItem["Township"].isNull())
+				addressesObject.township = valueFilesFilesItemAddressesAddressesItem["Township"].asString();
+			filesObject.addresses.push_back(addressesObject);
+		}
+		auto allFiguresNode = valueFilesFilesItem["Figures"]["FiguresItem"];
+		for (auto valueFilesFilesItemFiguresFiguresItem : allFiguresNode)
+		{
+			FilesItem::FiguresItem figuresObject;
+			if(!valueFilesFilesItemFiguresFiguresItem["FigureId"].isNull())
+				figuresObject.figureId = valueFilesFilesItemFiguresFiguresItem["FigureId"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["FigureConfidence"].isNull())
+				figuresObject.figureConfidence = std::stof(valueFilesFilesItemFiguresFiguresItem["FigureConfidence"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["FigureClusterId"].isNull())
+				figuresObject.figureClusterId = valueFilesFilesItemFiguresFiguresItem["FigureClusterId"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["FigureClusterConfidence"].isNull())
+				figuresObject.figureClusterConfidence = std::stof(valueFilesFilesItemFiguresFiguresItem["FigureClusterConfidence"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["FigureType"].isNull())
+				figuresObject.figureType = valueFilesFilesItemFiguresFiguresItem["FigureType"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["Age"].isNull())
+				figuresObject.age = std::stol(valueFilesFilesItemFiguresFiguresItem["Age"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["AgeSD"].isNull())
+				figuresObject.ageSD = std::stof(valueFilesFilesItemFiguresFiguresItem["AgeSD"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["Gender"].isNull())
+				figuresObject.gender = valueFilesFilesItemFiguresFiguresItem["Gender"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["GenderConfidence"].isNull())
+				figuresObject.genderConfidence = std::stof(valueFilesFilesItemFiguresFiguresItem["GenderConfidence"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["Emotion"].isNull())
+				figuresObject.emotion = valueFilesFilesItemFiguresFiguresItem["Emotion"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["EmotionConfidence"].isNull())
+				figuresObject.emotionConfidence = std::stof(valueFilesFilesItemFiguresFiguresItem["EmotionConfidence"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["FaceQuality"].isNull())
+				figuresObject.faceQuality = std::stof(valueFilesFilesItemFiguresFiguresItem["FaceQuality"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["Mouth"].isNull())
+				figuresObject.mouth = valueFilesFilesItemFiguresFiguresItem["Mouth"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["MouthConfidence"].isNull())
+				figuresObject.mouthConfidence = std::stof(valueFilesFilesItemFiguresFiguresItem["MouthConfidence"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["Beard"].isNull())
+				figuresObject.beard = valueFilesFilesItemFiguresFiguresItem["Beard"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["BeardConfidence"].isNull())
+				figuresObject.beardConfidence = std::stof(valueFilesFilesItemFiguresFiguresItem["BeardConfidence"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["Hat"].isNull())
+				figuresObject.hat = valueFilesFilesItemFiguresFiguresItem["Hat"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["HatConfidence"].isNull())
+				figuresObject.hatConfidence = std::stof(valueFilesFilesItemFiguresFiguresItem["HatConfidence"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["Mask"].isNull())
+				figuresObject.mask = valueFilesFilesItemFiguresFiguresItem["Mask"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["MaskConfidence"].isNull())
+				figuresObject.maskConfidence = std::stof(valueFilesFilesItemFiguresFiguresItem["MaskConfidence"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["Glasses"].isNull())
+				figuresObject.glasses = valueFilesFilesItemFiguresFiguresItem["Glasses"].asString();
+			if(!valueFilesFilesItemFiguresFiguresItem["GlassesConfidence"].isNull())
+				figuresObject.glassesConfidence = std::stof(valueFilesFilesItemFiguresFiguresItem["GlassesConfidence"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["Sharpness"].isNull())
+				figuresObject.sharpness = std::stof(valueFilesFilesItemFiguresFiguresItem["Sharpness"].asString());
+			if(!valueFilesFilesItemFiguresFiguresItem["Attractive"].isNull())
+				figuresObject.attractive = std::stof(valueFilesFilesItemFiguresFiguresItem["Attractive"].asString());
+			auto boundaryNode = value["Boundary"];
+			if(!boundaryNode["Width"].isNull())
+				figuresObject.boundary.width = std::stol(boundaryNode["Width"].asString());
+			if(!boundaryNode["Height"].isNull())
+				figuresObject.boundary.height = std::stol(boundaryNode["Height"].asString());
+			if(!boundaryNode["Left"].isNull())
+				figuresObject.boundary.left = std::stol(boundaryNode["Left"].asString());
+			if(!boundaryNode["Top"].isNull())
+				figuresObject.boundary.top = std::stol(boundaryNode["Top"].asString());
+			auto headPoseNode = value["HeadPose"];
+			if(!headPoseNode["Pitch"].isNull())
+				figuresObject.headPose.pitch = std::stof(headPoseNode["Pitch"].asString());
+			if(!headPoseNode["Roll"].isNull())
+				figuresObject.headPose.roll = std::stof(headPoseNode["Roll"].asString());
+			if(!headPoseNode["Yaw"].isNull())
+				figuresObject.headPose.yaw = std::stof(headPoseNode["Yaw"].asString());
+			filesObject.figures.push_back(figuresObject);
+		}
+		auto allLabelsNode = valueFilesFilesItem["Labels"]["LabelsItem"];
+		for (auto valueFilesFilesItemLabelsLabelsItem : allLabelsNode)
+		{
+			FilesItem::LabelsItem labelsObject;
+			if(!valueFilesFilesItemLabelsLabelsItem["Language"].isNull())
+				labelsObject.language = valueFilesFilesItemLabelsLabelsItem["Language"].asString();
+			if(!valueFilesFilesItemLabelsLabelsItem["LabelName"].isNull())
+				labelsObject.labelName = valueFilesFilesItemLabelsLabelsItem["LabelName"].asString();
+			if(!valueFilesFilesItemLabelsLabelsItem["LabelLevel"].isNull())
+				labelsObject.labelLevel = std::stol(valueFilesFilesItemLabelsLabelsItem["LabelLevel"].asString());
+			if(!valueFilesFilesItemLabelsLabelsItem["LabelConfidence"].isNull())
+				labelsObject.labelConfidence = std::stof(valueFilesFilesItemLabelsLabelsItem["LabelConfidence"].asString());
+			if(!valueFilesFilesItemLabelsLabelsItem["ParentLabelName"].isNull())
+				labelsObject.parentLabelName = valueFilesFilesItemLabelsLabelsItem["ParentLabelName"].asString();
+			if(!valueFilesFilesItemLabelsLabelsItem["CentricScore"].isNull())
+				labelsObject.centricScore = std::stof(valueFilesFilesItemLabelsLabelsItem["CentricScore"].asString());
+			filesObject.labels.push_back(labelsObject);
+		}
+		auto allCroppingSuggestionsNode = valueFilesFilesItem["CroppingSuggestions"]["CroppingSuggestionsItem"];
+		for (auto valueFilesFilesItemCroppingSuggestionsCroppingSuggestionsItem : allCroppingSuggestionsNode)
+		{
+			FilesItem::CroppingSuggestionsItem croppingSuggestionsObject;
+			if(!valueFilesFilesItemCroppingSuggestionsCroppingSuggestionsItem["AspectRatio"].isNull())
+				croppingSuggestionsObject.aspectRatio = valueFilesFilesItemCroppingSuggestionsCroppingSuggestionsItem["AspectRatio"].asString();
+			if(!valueFilesFilesItemCroppingSuggestionsCroppingSuggestionsItem["Confidence"].isNull())
+				croppingSuggestionsObject.confidence = std::stof(valueFilesFilesItemCroppingSuggestionsCroppingSuggestionsItem["Confidence"].asString());
+			auto boundary1Node = value["Boundary"];
+			if(!boundary1Node["Width"].isNull())
+				croppingSuggestionsObject.boundary1.width = std::stol(boundary1Node["Width"].asString());
+			if(!boundary1Node["Height"].isNull())
+				croppingSuggestionsObject.boundary1.height = std::stol(boundary1Node["Height"].asString());
+			if(!boundary1Node["Left"].isNull())
+				croppingSuggestionsObject.boundary1.left = std::stol(boundary1Node["Left"].asString());
+			if(!boundary1Node["Top"].isNull())
+				croppingSuggestionsObject.boundary1.top = std::stol(boundary1Node["Top"].asString());
+			filesObject.croppingSuggestions.push_back(croppingSuggestionsObject);
+		}
+		auto allOCRContentsNode = valueFilesFilesItem["OCRContents"]["OCRContentsItem"];
+		for (auto valueFilesFilesItemOCRContentsOCRContentsItem : allOCRContentsNode)
+		{
+			FilesItem::OCRContentsItem oCRContentsObject;
+			if(!valueFilesFilesItemOCRContentsOCRContentsItem["Language"].isNull())
+				oCRContentsObject.language = valueFilesFilesItemOCRContentsOCRContentsItem["Language"].asString();
+			if(!valueFilesFilesItemOCRContentsOCRContentsItem["Contents"].isNull())
+				oCRContentsObject.contents = valueFilesFilesItemOCRContentsOCRContentsItem["Contents"].asString();
+			if(!valueFilesFilesItemOCRContentsOCRContentsItem["Confidence"].isNull())
+				oCRContentsObject.confidence = std::stof(valueFilesFilesItemOCRContentsOCRContentsItem["Confidence"].asString());
+			auto boundary2Node = value["Boundary"];
+			if(!boundary2Node["Width"].isNull())
+				oCRContentsObject.boundary2.width = std::stol(boundary2Node["Width"].asString());
+			if(!boundary2Node["Height"].isNull())
+				oCRContentsObject.boundary2.height = std::stol(boundary2Node["Height"].asString());
+			if(!boundary2Node["Left"].isNull())
+				oCRContentsObject.boundary2.left = std::stol(boundary2Node["Left"].asString());
+			if(!boundary2Node["Top"].isNull())
+				oCRContentsObject.boundary2.top = std::stol(boundary2Node["Top"].asString());
+			filesObject.oCRContents.push_back(oCRContentsObject);
+		}
+		auto allVideoStreamsNode = valueFilesFilesItem["VideoStreams"]["VideoStreamsItem"];
+		for (auto valueFilesFilesItemVideoStreamsVideoStreamsItem : allVideoStreamsNode)
+		{
+			FilesItem::VideoStreamsItem videoStreamsObject;
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["Index"].isNull())
+				videoStreamsObject.index = std::stol(valueFilesFilesItemVideoStreamsVideoStreamsItem["Index"].asString());
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["Language"].isNull())
+				videoStreamsObject.language = valueFilesFilesItemVideoStreamsVideoStreamsItem["Language"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecName"].isNull())
+				videoStreamsObject.codecName = valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecName"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecLongName"].isNull())
+				videoStreamsObject.codecLongName = valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecLongName"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["Profile"].isNull())
+				videoStreamsObject.profile = valueFilesFilesItemVideoStreamsVideoStreamsItem["Profile"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecTimeBase"].isNull())
+				videoStreamsObject.codecTimeBase = valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecTimeBase"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecTagString"].isNull())
+				videoStreamsObject.codecTagString = valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecTagString"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecTag"].isNull())
+				videoStreamsObject.codecTag = valueFilesFilesItemVideoStreamsVideoStreamsItem["CodecTag"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["Width"].isNull())
+				videoStreamsObject.width = std::stol(valueFilesFilesItemVideoStreamsVideoStreamsItem["Width"].asString());
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["Height"].isNull())
+				videoStreamsObject.height = std::stol(valueFilesFilesItemVideoStreamsVideoStreamsItem["Height"].asString());
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["HasBFrames"].isNull())
+				videoStreamsObject.hasBFrames = std::stol(valueFilesFilesItemVideoStreamsVideoStreamsItem["HasBFrames"].asString());
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["SampleAspectRatio"].isNull())
+				videoStreamsObject.sampleAspectRatio = valueFilesFilesItemVideoStreamsVideoStreamsItem["SampleAspectRatio"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["DisplayAspectRatio"].isNull())
+				videoStreamsObject.displayAspectRatio = valueFilesFilesItemVideoStreamsVideoStreamsItem["DisplayAspectRatio"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["PixelFormat"].isNull())
+				videoStreamsObject.pixelFormat = valueFilesFilesItemVideoStreamsVideoStreamsItem["PixelFormat"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["Level"].isNull())
+				videoStreamsObject.level = std::stol(valueFilesFilesItemVideoStreamsVideoStreamsItem["Level"].asString());
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["FrameRate"].isNull())
+				videoStreamsObject.frameRate = valueFilesFilesItemVideoStreamsVideoStreamsItem["FrameRate"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["AverageFrameRate"].isNull())
+				videoStreamsObject.averageFrameRate = valueFilesFilesItemVideoStreamsVideoStreamsItem["AverageFrameRate"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["TimeBase"].isNull())
+				videoStreamsObject.timeBase = valueFilesFilesItemVideoStreamsVideoStreamsItem["TimeBase"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["StartTime"].isNull())
+				videoStreamsObject.startTime = valueFilesFilesItemVideoStreamsVideoStreamsItem["StartTime"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["Duration"].isNull())
+				videoStreamsObject.duration = valueFilesFilesItemVideoStreamsVideoStreamsItem["Duration"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["Bitrate"].isNull())
+				videoStreamsObject.bitrate = std::stol(valueFilesFilesItemVideoStreamsVideoStreamsItem["Bitrate"].asString());
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["FrameCount"].isNull())
+				videoStreamsObject.frameCount = std::stol(valueFilesFilesItemVideoStreamsVideoStreamsItem["FrameCount"].asString());
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["Rotate"].isNull())
+				videoStreamsObject.rotate = valueFilesFilesItemVideoStreamsVideoStreamsItem["Rotate"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["BitDepth"].isNull())
+				videoStreamsObject.bitDepth = std::stol(valueFilesFilesItemVideoStreamsVideoStreamsItem["BitDepth"].asString());
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["ColorSpace"].isNull())
+				videoStreamsObject.colorSpace = valueFilesFilesItemVideoStreamsVideoStreamsItem["ColorSpace"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["ColorRange"].isNull())
+				videoStreamsObject.colorRange = valueFilesFilesItemVideoStreamsVideoStreamsItem["ColorRange"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["ColorTransfer"].isNull())
+				videoStreamsObject.colorTransfer = valueFilesFilesItemVideoStreamsVideoStreamsItem["ColorTransfer"].asString();
+			if(!valueFilesFilesItemVideoStreamsVideoStreamsItem["ColorPrimaries"].isNull())
+				videoStreamsObject.colorPrimaries = valueFilesFilesItemVideoStreamsVideoStreamsItem["ColorPrimaries"].asString();
+			filesObject.videoStreams.push_back(videoStreamsObject);
+		}
+		auto allSubtitlesNode = valueFilesFilesItem["Subtitles"]["SubtitlesItem"];
+		for (auto valueFilesFilesItemSubtitlesSubtitlesItem : allSubtitlesNode)
+		{
+			FilesItem::SubtitlesItem subtitlesObject;
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["Index"].isNull())
+				subtitlesObject.index = std::stol(valueFilesFilesItemSubtitlesSubtitlesItem["Index"].asString());
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["Language"].isNull())
+				subtitlesObject.language = valueFilesFilesItemSubtitlesSubtitlesItem["Language"].asString();
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["CodecName"].isNull())
+				subtitlesObject.codecName = valueFilesFilesItemSubtitlesSubtitlesItem["CodecName"].asString();
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["CodecLongName"].isNull())
+				subtitlesObject.codecLongName = valueFilesFilesItemSubtitlesSubtitlesItem["CodecLongName"].asString();
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["CodecTagString"].isNull())
+				subtitlesObject.codecTagString = valueFilesFilesItemSubtitlesSubtitlesItem["CodecTagString"].asString();
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["CodecTag"].isNull())
+				subtitlesObject.codecTag = valueFilesFilesItemSubtitlesSubtitlesItem["CodecTag"].asString();
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["StartTime"].isNull())
+				subtitlesObject.startTime = valueFilesFilesItemSubtitlesSubtitlesItem["StartTime"].asString();
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["Duration"].isNull())
+				subtitlesObject.duration = valueFilesFilesItemSubtitlesSubtitlesItem["Duration"].asString();
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["Bitrate"].isNull())
+				subtitlesObject.bitrate = std::stol(valueFilesFilesItemSubtitlesSubtitlesItem["Bitrate"].asString());
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["Content"].isNull())
+				subtitlesObject.content = valueFilesFilesItemSubtitlesSubtitlesItem["Content"].asString();
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["Width"].isNull())
+				subtitlesObject.width = std::stol(valueFilesFilesItemSubtitlesSubtitlesItem["Width"].asString());
+			if(!valueFilesFilesItemSubtitlesSubtitlesItem["Height"].isNull())
+				subtitlesObject.height = std::stol(valueFilesFilesItemSubtitlesSubtitlesItem["Height"].asString());
+			filesObject.subtitles.push_back(subtitlesObject);
+		}
+		auto allAudioStreamsNode = valueFilesFilesItem["AudioStreams"]["AudioStreamsItem"];
+		for (auto valueFilesFilesItemAudioStreamsAudioStreamsItem : allAudioStreamsNode)
+		{
+			FilesItem::AudioStreamsItem audioStreamsObject;
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["Index"].isNull())
+				audioStreamsObject.index = std::stol(valueFilesFilesItemAudioStreamsAudioStreamsItem["Index"].asString());
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["Language"].isNull())
+				audioStreamsObject.language = valueFilesFilesItemAudioStreamsAudioStreamsItem["Language"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecName"].isNull())
+				audioStreamsObject.codecName = valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecName"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecLongName"].isNull())
+				audioStreamsObject.codecLongName = valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecLongName"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecTimeBase"].isNull())
+				audioStreamsObject.codecTimeBase = valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecTimeBase"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecTagString"].isNull())
+				audioStreamsObject.codecTagString = valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecTagString"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecTag"].isNull())
+				audioStreamsObject.codecTag = valueFilesFilesItemAudioStreamsAudioStreamsItem["CodecTag"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["TimeBase"].isNull())
+				audioStreamsObject.timeBase = valueFilesFilesItemAudioStreamsAudioStreamsItem["TimeBase"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["StartTime"].isNull())
+				audioStreamsObject.startTime = valueFilesFilesItemAudioStreamsAudioStreamsItem["StartTime"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["Duration"].isNull())
+				audioStreamsObject.duration = valueFilesFilesItemAudioStreamsAudioStreamsItem["Duration"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["Bitrate"].isNull())
+				audioStreamsObject.bitrate = std::stol(valueFilesFilesItemAudioStreamsAudioStreamsItem["Bitrate"].asString());
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["FrameCount"].isNull())
+				audioStreamsObject.frameCount = std::stol(valueFilesFilesItemAudioStreamsAudioStreamsItem["FrameCount"].asString());
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["Lyric"].isNull())
+				audioStreamsObject.lyric = valueFilesFilesItemAudioStreamsAudioStreamsItem["Lyric"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["SampleFormat"].isNull())
+				audioStreamsObject.sampleFormat = valueFilesFilesItemAudioStreamsAudioStreamsItem["SampleFormat"].asString();
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["SampleRate"].isNull())
+				audioStreamsObject.sampleRate = std::stol(valueFilesFilesItemAudioStreamsAudioStreamsItem["SampleRate"].asString());
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["Channels"].isNull())
+				audioStreamsObject.channels = std::stol(valueFilesFilesItemAudioStreamsAudioStreamsItem["Channels"].asString());
+			if(!valueFilesFilesItemAudioStreamsAudioStreamsItem["ChannelLayout"].isNull())
+				audioStreamsObject.channelLayout = valueFilesFilesItemAudioStreamsAudioStreamsItem["ChannelLayout"].asString();
+			filesObject.audioStreams.push_back(audioStreamsObject);
+		}
+		auto allAudioCoversNode = valueFilesFilesItem["AudioCovers"]["AudioCoversItem"];
+		for (auto valueFilesFilesItemAudioCoversAudioCoversItem : allAudioCoversNode)
+		{
+			FilesItem::AudioCoversItem audioCoversObject;
+			if(!valueFilesFilesItemAudioCoversAudioCoversItem["ImageWidth"].isNull())
+				audioCoversObject.imageWidth = std::stol(valueFilesFilesItemAudioCoversAudioCoversItem["ImageWidth"].asString());
+			if(!valueFilesFilesItemAudioCoversAudioCoversItem["ImageHeight"].isNull())
+				audioCoversObject.imageHeight = std::stol(valueFilesFilesItemAudioCoversAudioCoversItem["ImageHeight"].asString());
+			if(!valueFilesFilesItemAudioCoversAudioCoversItem["EXIF"].isNull())
+				audioCoversObject.eXIF = valueFilesFilesItemAudioCoversAudioCoversItem["EXIF"].asString();
+			auto allCroppingSuggestions4Node = valueFilesFilesItemAudioCoversAudioCoversItem["CroppingSuggestions"]["CroppingSuggestionsItem"];
+			for (auto valueFilesFilesItemAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem : allCroppingSuggestions4Node)
+			{
+				FilesItem::AudioCoversItem::CroppingSuggestionsItem6 croppingSuggestions4Object;
+				if(!valueFilesFilesItemAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem["AspectRatio"].isNull())
+					croppingSuggestions4Object.aspectRatio = valueFilesFilesItemAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem["AspectRatio"].asString();
+				if(!valueFilesFilesItemAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem["Confidence"].isNull())
+					croppingSuggestions4Object.confidence = std::stof(valueFilesFilesItemAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem["Confidence"].asString());
+				auto boundary7Node = value["Boundary"];
+				if(!boundary7Node["Width"].isNull())
+					croppingSuggestions4Object.boundary7.width = std::stol(boundary7Node["Width"].asString());
+				if(!boundary7Node["Height"].isNull())
+					croppingSuggestions4Object.boundary7.height = std::stol(boundary7Node["Height"].asString());
+				if(!boundary7Node["Left"].isNull())
+					croppingSuggestions4Object.boundary7.left = std::stol(boundary7Node["Left"].asString());
+				if(!boundary7Node["Top"].isNull())
+					croppingSuggestions4Object.boundary7.top = std::stol(boundary7Node["Top"].asString());
+				audioCoversObject.croppingSuggestions4.push_back(croppingSuggestions4Object);
+			}
+			auto allOCRContents5Node = valueFilesFilesItemAudioCoversAudioCoversItem["OCRContents"]["OCRContentsItem"];
+			for (auto valueFilesFilesItemAudioCoversAudioCoversItemOCRContentsOCRContentsItem : allOCRContents5Node)
+			{
+				FilesItem::AudioCoversItem::OCRContentsItem8 oCRContents5Object;
+				if(!valueFilesFilesItemAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Language"].isNull())
+					oCRContents5Object.language = valueFilesFilesItemAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Language"].asString();
+				if(!valueFilesFilesItemAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Contents"].isNull())
+					oCRContents5Object.contents = valueFilesFilesItemAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Contents"].asString();
+				if(!valueFilesFilesItemAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Confidence"].isNull())
+					oCRContents5Object.confidence = std::stof(valueFilesFilesItemAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Confidence"].asString());
+				auto boundary9Node = value["Boundary"];
+				if(!boundary9Node["Width"].isNull())
+					oCRContents5Object.boundary9.width = std::stol(boundary9Node["Width"].asString());
+				if(!boundary9Node["Height"].isNull())
+					oCRContents5Object.boundary9.height = std::stol(boundary9Node["Height"].asString());
+				if(!boundary9Node["Left"].isNull())
+					oCRContents5Object.boundary9.left = std::stol(boundary9Node["Left"].asString());
+				if(!boundary9Node["Top"].isNull())
+					oCRContents5Object.boundary9.top = std::stol(boundary9Node["Top"].asString());
+				audioCoversObject.oCRContents5.push_back(oCRContents5Object);
+			}
+			auto imageScore3Node = value["ImageScore"];
+			if(!imageScore3Node["OverallQualityScore"].isNull())
+				audioCoversObject.imageScore3.overallQualityScore = std::stof(imageScore3Node["OverallQualityScore"].asString());
+			filesObject.audioCovers.push_back(audioCoversObject);
+		}
+		auto imageScoreNode = value["ImageScore"];
+		if(!imageScoreNode["OverallQualityScore"].isNull())
+			filesObject.imageScore.overallQualityScore = std::stof(imageScoreNode["OverallQualityScore"].asString());
+		files_.push_back(filesObject);
+	}
+
+}
+
+std::vector<BatchGetFileMetaResult::FilesItem> BatchGetFileMetaResult::getFiles()const
+{
+	return files_;
+}
+

imm/src/model/BatchIndexFileMetaRequest.cc

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/BatchIndexFileMetaRequest.h>
+
+using AlibabaCloud::Imm::Model::BatchIndexFileMetaRequest;
+
+BatchIndexFileMetaRequest::BatchIndexFileMetaRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "BatchIndexFileMeta") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+BatchIndexFileMetaRequest::~BatchIndexFileMetaRequest() {}
+
+std::string BatchIndexFileMetaRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void BatchIndexFileMetaRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string BatchIndexFileMetaRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void BatchIndexFileMetaRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string BatchIndexFileMetaRequest::getProjectName() const {
+  return projectName_;
+}
+
+void BatchIndexFileMetaRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string BatchIndexFileMetaRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void BatchIndexFileMetaRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+std::vector<BatchIndexFileMetaRequest::Files> BatchIndexFileMetaRequest::getFiles() const {
+  return files_;
+}
+
+void BatchIndexFileMetaRequest::setFiles(const std::vector<BatchIndexFileMetaRequest::Files> &files) {
+  files_ = files;
+  for(int dep1 = 0; dep1 != files.size(); dep1++) {
+    for(auto const &iter2 : files[dep1].customLabels) {
+      setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".CustomLabels." + iter2.first, iter2.second);
+    }
+    for(int dep2 = 0; dep2 != files[dep1].figures.size(); dep2++) {
+      setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".Figures." + std::to_string(dep2 + 1) + ".FigureId", files[dep1].figures[dep2].figureId);
+      setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".Figures." + std::to_string(dep2 + 1) + ".FigureClusterId", files[dep1].figures[dep2].figureClusterId);
+      setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".Figures." + std::to_string(dep2 + 1) + ".FigureType", files[dep1].figures[dep2].figureType);
+    }
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".OSSURI", files[dep1].oSSURI);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".FileHash", files[dep1].fileHash);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".URI", files[dep1].uRI);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".CustomId", files[dep1].customId);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".MediaType", files[dep1].mediaType);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".ContentType", files[dep1].contentType);
+  }
+}
+

imm/src/model/BatchIndexFileMetaResult.cc

@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/OpenImmServiceResult.h>
+#include <alibabacloud/imm/model/BatchIndexFileMetaResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-OpenImmServiceResult::OpenImmServiceResult() :
+BatchIndexFileMetaResult::BatchIndexFileMetaResult() :
 	ServiceResult()
 {}
 
-OpenImmServiceResult::OpenImmServiceResult(const std::string &payload) :
+BatchIndexFileMetaResult::BatchIndexFileMetaResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-OpenImmServiceResult::~OpenImmServiceResult()
+BatchIndexFileMetaResult::~BatchIndexFileMetaResult()
 {}
 
-void OpenImmServiceResult::parse(const std::string &payload)
+void BatchIndexFileMetaResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["OrderId"].isNull())
-		orderId_ = value["OrderId"].asString();
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
 
 }
 
-std::string OpenImmServiceResult::getOrderId()const
+std::string BatchIndexFileMetaResult::getEventId()const
 {
-	return orderId_;
+	return eventId_;
 }
 

imm/src/model/BatchUpdateFileMetaRequest.cc

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/BatchUpdateFileMetaRequest.h>
+
+using AlibabaCloud::Imm::Model::BatchUpdateFileMetaRequest;
+
+BatchUpdateFileMetaRequest::BatchUpdateFileMetaRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "BatchUpdateFileMeta") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+BatchUpdateFileMetaRequest::~BatchUpdateFileMetaRequest() {}
+
+std::string BatchUpdateFileMetaRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void BatchUpdateFileMetaRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string BatchUpdateFileMetaRequest::getProjectName() const {
+  return projectName_;
+}
+
+void BatchUpdateFileMetaRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::vector<BatchUpdateFileMetaRequest::Files> BatchUpdateFileMetaRequest::getFiles() const {
+  return files_;
+}
+
+void BatchUpdateFileMetaRequest::setFiles(const std::vector<BatchUpdateFileMetaRequest::Files> &files) {
+  files_ = files;
+  for(int dep1 = 0; dep1 != files.size(); dep1++) {
+    for(auto const &iter2 : files[dep1].customLabels) {
+      setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".CustomLabels." + iter2.first, iter2.second);
+    }
+    for(int dep2 = 0; dep2 != files[dep1].figures.size(); dep2++) {
+      setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".Figures." + std::to_string(dep2 + 1) + ".FigureId", files[dep1].figures[dep2].figureId);
+      setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".Figures." + std::to_string(dep2 + 1) + ".FigureClusterId", files[dep1].figures[dep2].figureClusterId);
+      setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".Figures." + std::to_string(dep2 + 1) + ".FigureType", files[dep1].figures[dep2].figureType);
+    }
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".OSSURI", files[dep1].oSSURI);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".FileHash", files[dep1].fileHash);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".URI", files[dep1].uRI);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".CustomId", files[dep1].customId);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".MediaType", files[dep1].mediaType);
+    setParameter(std::string("Files") + "." + std::to_string(dep1 + 1) + ".ContentType", files[dep1].contentType);
+  }
+}
+

imm/src/model/BatchUpdateFileMetaResult.cc

@@ -14,52 +14,48 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateGroupFacesJobResult.h>
+#include <alibabacloud/imm/model/BatchUpdateFileMetaResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateGroupFacesJobResult::CreateGroupFacesJobResult() :
+BatchUpdateFileMetaResult::BatchUpdateFileMetaResult() :
 	ServiceResult()
 {}
 
-CreateGroupFacesJobResult::CreateGroupFacesJobResult(const std::string &payload) :
+BatchUpdateFileMetaResult::BatchUpdateFileMetaResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateGroupFacesJobResult::~CreateGroupFacesJobResult()
+BatchUpdateFileMetaResult::~BatchUpdateFileMetaResult()
 {}
 
-void CreateGroupFacesJobResult::parse(const std::string &payload)
+void BatchUpdateFileMetaResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["JobType"].isNull())
-		jobType_ = value["JobType"].asString();
-	if(!value["SetId"].isNull())
-		setId_ = value["SetId"].asString();
-	if(!value["JobId"].isNull())
-		jobId_ = value["JobId"].asString();
+	auto allFilesNode = value["Files"]["FilesItem"];
+	for (auto valueFilesFilesItem : allFilesNode)
+	{
+		FilesItem filesObject;
+		if(!valueFilesFilesItem["URI"].isNull())
+			filesObject.uRI = valueFilesFilesItem["URI"].asString();
+		if(!valueFilesFilesItem["Success"].isNull())
+			filesObject.success = valueFilesFilesItem["Success"].asString() == "true";
+		if(!valueFilesFilesItem["Message"].isNull())
+			filesObject.message = valueFilesFilesItem["Message"].asString();
+		files_.push_back(filesObject);
+	}
 
 }
 
-std::string CreateGroupFacesJobResult::getJobType()const
+std::vector<BatchUpdateFileMetaResult::FilesItem> BatchUpdateFileMetaResult::getFiles()const
 {
-	return jobType_;
-}
-
-std::string CreateGroupFacesJobResult::getSetId()const
-{
-	return setId_;
-}
-
-std::string CreateGroupFacesJobResult::getJobId()const
-{
-	return jobId_;
+	return files_;
 }
 

imm/src/model/CompareImageFacesRequest.cc

@@ -1,90 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CompareImageFacesRequest.h>
-
-using AlibabaCloud::Imm::Model::CompareImageFacesRequest;
-
-CompareImageFacesRequest::CompareImageFacesRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CompareImageFaces") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CompareImageFacesRequest::~CompareImageFacesRequest() {}
-
-std::string CompareImageFacesRequest::getProject() const {
-  return project_;
-}
-
-void CompareImageFacesRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CompareImageFacesRequest::getFaceIdA() const {
-  return faceIdA_;
-}
-
-void CompareImageFacesRequest::setFaceIdA(const std::string &faceIdA) {
-  faceIdA_ = faceIdA;
-  setParameter(std::string("FaceIdA"), faceIdA);
-}
-
-std::string CompareImageFacesRequest::getFaceIdB() const {
-  return faceIdB_;
-}
-
-void CompareImageFacesRequest::setFaceIdB(const std::string &faceIdB) {
-  faceIdB_ = faceIdB;
-  setParameter(std::string("FaceIdB"), faceIdB);
-}
-
-std::string CompareImageFacesRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CompareImageFacesRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CompareImageFacesRequest::getImageUriB() const {
-  return imageUriB_;
-}
-
-void CompareImageFacesRequest::setImageUriB(const std::string &imageUriB) {
-  imageUriB_ = imageUriB;
-  setParameter(std::string("ImageUriB"), imageUriB);
-}
-
-std::string CompareImageFacesRequest::getImageUriA() const {
-  return imageUriA_;
-}
-
-void CompareImageFacesRequest::setImageUriA(const std::string &imageUriA) {
-  imageUriA_ = imageUriA;
-  setParameter(std::string("ImageUriA"), imageUriA);
-}
-
-std::string CompareImageFacesRequest::getSetId() const {
-  return setId_;
-}
-
-void CompareImageFacesRequest::setSetId(const std::string &setId) {
-  setId_ = setId;
-  setParameter(std::string("SetId"), setId);
-}
-

imm/src/model/CompareImageFacesResult.cc

@@ -1,94 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CompareImageFacesResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-CompareImageFacesResult::CompareImageFacesResult() :
-	ServiceResult()
-{}
-
-CompareImageFacesResult::CompareImageFacesResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-CompareImageFacesResult::~CompareImageFacesResult()
-{}
-
-void CompareImageFacesResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto faceANode = value["FaceA"];
-	if(!faceANode["FaceId"].isNull())
-		faceA_.faceId = faceANode["FaceId"].asString();
-	auto faceAttributesNode = faceANode["FaceAttributes"];
-	auto faceBoundaryNode = faceAttributesNode["FaceBoundary"];
-	if(!faceBoundaryNode["Top"].isNull())
-		faceA_.faceAttributes.faceBoundary.top = std::stoi(faceBoundaryNode["Top"].asString());
-	if(!faceBoundaryNode["Width"].isNull())
-		faceA_.faceAttributes.faceBoundary.width = std::stoi(faceBoundaryNode["Width"].asString());
-	if(!faceBoundaryNode["Height"].isNull())
-		faceA_.faceAttributes.faceBoundary.height = std::stoi(faceBoundaryNode["Height"].asString());
-	if(!faceBoundaryNode["Left"].isNull())
-		faceA_.faceAttributes.faceBoundary.left = std::stoi(faceBoundaryNode["Left"].asString());
-	auto faceBNode = value["FaceB"];
-	if(!faceBNode["FaceId"].isNull())
-		faceB_.faceId = faceBNode["FaceId"].asString();
-	auto faceAttributes1Node = faceBNode["FaceAttributes"];
-	auto faceBoundary2Node = faceAttributes1Node["FaceBoundary"];
-	if(!faceBoundary2Node["Top"].isNull())
-		faceB_.faceAttributes1.faceBoundary2.top = std::stoi(faceBoundary2Node["Top"].asString());
-	if(!faceBoundary2Node["Width"].isNull())
-		faceB_.faceAttributes1.faceBoundary2.width = std::stoi(faceBoundary2Node["Width"].asString());
-	if(!faceBoundary2Node["Height"].isNull())
-		faceB_.faceAttributes1.faceBoundary2.height = std::stoi(faceBoundary2Node["Height"].asString());
-	if(!faceBoundary2Node["Left"].isNull())
-		faceB_.faceAttributes1.faceBoundary2.left = std::stoi(faceBoundary2Node["Left"].asString());
-	if(!value["Similarity"].isNull())
-		similarity_ = std::stof(value["Similarity"].asString());
-	if(!value["SetId"].isNull())
-		setId_ = value["SetId"].asString();
-
-}
-
-float CompareImageFacesResult::getSimilarity()const
-{
-	return similarity_;
-}
-
-CompareImageFacesResult::FaceA CompareImageFacesResult::getFaceA()const
-{
-	return faceA_;
-}
-
-std::string CompareImageFacesResult::getSetId()const
-{
-	return setId_;
-}
-
-CompareImageFacesResult::FaceB CompareImageFacesResult::getFaceB()const
-{
-	return faceB_;
-}
-

imm/src/model/ConvertOfficeFormatRequest.cc

@@ -1,216 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/ConvertOfficeFormatRequest.h>
-
-using AlibabaCloud::Imm::Model::ConvertOfficeFormatRequest;
-
-ConvertOfficeFormatRequest::ConvertOfficeFormatRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "ConvertOfficeFormat") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-ConvertOfficeFormatRequest::~ConvertOfficeFormatRequest() {}
-
-std::string ConvertOfficeFormatRequest::getSrcType() const {
-  return srcType_;
-}
-
-void ConvertOfficeFormatRequest::setSrcType(const std::string &srcType) {
-  srcType_ = srcType;
-  setParameter(std::string("SrcType"), srcType);
-}
-
-std::string ConvertOfficeFormatRequest::getProject() const {
-  return project_;
-}
-
-void ConvertOfficeFormatRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-bool ConvertOfficeFormatRequest::getPdfVector() const {
-  return pdfVector_;
-}
-
-void ConvertOfficeFormatRequest::setPdfVector(bool pdfVector) {
-  pdfVector_ = pdfVector;
-  setParameter(std::string("PdfVector"), pdfVector ? "true" : "false");
-}
-
-std::string ConvertOfficeFormatRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void ConvertOfficeFormatRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string ConvertOfficeFormatRequest::getPassword() const {
-  return password_;
-}
-
-void ConvertOfficeFormatRequest::setPassword(const std::string &password) {
-  password_ = password;
-  setParameter(std::string("Password"), password);
-}
-
-long ConvertOfficeFormatRequest::getStartPage() const {
-  return startPage_;
-}
-
-void ConvertOfficeFormatRequest::setStartPage(long startPage) {
-  startPage_ = startPage;
-  setParameter(std::string("StartPage"), std::to_string(startPage));
-}
-
-bool ConvertOfficeFormatRequest::getFitToPagesWide() const {
-  return fitToPagesWide_;
-}
-
-void ConvertOfficeFormatRequest::setFitToPagesWide(bool fitToPagesWide) {
-  fitToPagesWide_ = fitToPagesWide;
-  setParameter(std::string("FitToPagesWide"), fitToPagesWide ? "true" : "false");
-}
-
-std::string ConvertOfficeFormatRequest::getTgtFilePrefix() const {
-  return tgtFilePrefix_;
-}
-
-void ConvertOfficeFormatRequest::setTgtFilePrefix(const std::string &tgtFilePrefix) {
-  tgtFilePrefix_ = tgtFilePrefix;
-  setParameter(std::string("TgtFilePrefix"), tgtFilePrefix);
-}
-
-std::string ConvertOfficeFormatRequest::getModelId() const {
-  return modelId_;
-}
-
-void ConvertOfficeFormatRequest::setModelId(const std::string &modelId) {
-  modelId_ = modelId;
-  setParameter(std::string("ModelId"), modelId);
-}
-
-long ConvertOfficeFormatRequest::getMaxSheetRow() const {
-  return maxSheetRow_;
-}
-
-void ConvertOfficeFormatRequest::setMaxSheetRow(long maxSheetRow) {
-  maxSheetRow_ = maxSheetRow;
-  setParameter(std::string("MaxSheetRow"), std::to_string(maxSheetRow));
-}
-
-long ConvertOfficeFormatRequest::getMaxSheetCount() const {
-  return maxSheetCount_;
-}
-
-void ConvertOfficeFormatRequest::setMaxSheetCount(long maxSheetCount) {
-  maxSheetCount_ = maxSheetCount;
-  setParameter(std::string("MaxSheetCount"), std::to_string(maxSheetCount));
-}
-
-long ConvertOfficeFormatRequest::getEndPage() const {
-  return endPage_;
-}
-
-void ConvertOfficeFormatRequest::setEndPage(long endPage) {
-  endPage_ = endPage;
-  setParameter(std::string("EndPage"), std::to_string(endPage));
-}
-
-std::string ConvertOfficeFormatRequest::getTgtFileSuffix() const {
-  return tgtFileSuffix_;
-}
-
-void ConvertOfficeFormatRequest::setTgtFileSuffix(const std::string &tgtFileSuffix) {
-  tgtFileSuffix_ = tgtFileSuffix;
-  setParameter(std::string("TgtFileSuffix"), tgtFileSuffix);
-}
-
-bool ConvertOfficeFormatRequest::getSheetOnePage() const {
-  return sheetOnePage_;
-}
-
-void ConvertOfficeFormatRequest::setSheetOnePage(bool sheetOnePage) {
-  sheetOnePage_ = sheetOnePage;
-  setParameter(std::string("SheetOnePage"), sheetOnePage ? "true" : "false");
-}
-
-long ConvertOfficeFormatRequest::getMaxSheetCol() const {
-  return maxSheetCol_;
-}
-
-void ConvertOfficeFormatRequest::setMaxSheetCol(long maxSheetCol) {
-  maxSheetCol_ = maxSheetCol;
-  setParameter(std::string("MaxSheetCol"), std::to_string(maxSheetCol));
-}
-
-std::string ConvertOfficeFormatRequest::getTgtType() const {
-  return tgtType_;
-}
-
-void ConvertOfficeFormatRequest::setTgtType(const std::string &tgtType) {
-  tgtType_ = tgtType;
-  setParameter(std::string("TgtType"), tgtType);
-}
-
-bool ConvertOfficeFormatRequest::getHidecomments() const {
-  return hidecomments_;
-}
-
-void ConvertOfficeFormatRequest::setHidecomments(bool hidecomments) {
-  hidecomments_ = hidecomments;
-  setParameter(std::string("Hidecomments"), hidecomments ? "true" : "false");
-}
-
-bool ConvertOfficeFormatRequest::getFitToPagesTall() const {
-  return fitToPagesTall_;
-}
-
-void ConvertOfficeFormatRequest::setFitToPagesTall(bool fitToPagesTall) {
-  fitToPagesTall_ = fitToPagesTall;
-  setParameter(std::string("FitToPagesTall"), fitToPagesTall ? "true" : "false");
-}
-
-std::string ConvertOfficeFormatRequest::getSrcUri() const {
-  return srcUri_;
-}
-
-void ConvertOfficeFormatRequest::setSrcUri(const std::string &srcUri) {
-  srcUri_ = srcUri;
-  setParameter(std::string("SrcUri"), srcUri);
-}
-
-std::string ConvertOfficeFormatRequest::getTgtFilePages() const {
-  return tgtFilePages_;
-}
-
-void ConvertOfficeFormatRequest::setTgtFilePages(const std::string &tgtFilePages) {
-  tgtFilePages_ = tgtFilePages;
-  setParameter(std::string("TgtFilePages"), tgtFilePages);
-}
-
-std::string ConvertOfficeFormatRequest::getTgtUri() const {
-  return tgtUri_;
-}
-
-void ConvertOfficeFormatRequest::setTgtUri(const std::string &tgtUri) {
-  tgtUri_ = tgtUri;
-  setParameter(std::string("TgtUri"), tgtUri);
-}
-

imm/src/model/CreateBindingRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/imm/model/CreateBindingRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateBindingRequest;
+
+CreateBindingRequest::CreateBindingRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateBinding") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateBindingRequest::~CreateBindingRequest() {}
+
+std::string CreateBindingRequest::getBucketOwnerId() const {
+  return bucketOwnerId_;
+}
+
+void CreateBindingRequest::setBucketOwnerId(const std::string &bucketOwnerId) {
+  bucketOwnerId_ = bucketOwnerId;
+  setParameter(std::string("BucketOwnerId"), bucketOwnerId);
+}
+
+std::string CreateBindingRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void CreateBindingRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string CreateBindingRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateBindingRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateBindingRequest::getURI() const {
+  return uRI_;
+}
+
+void CreateBindingRequest::setURI(const std::string &uRI) {
+  uRI_ = uRI;
+  setParameter(std::string("URI"), uRI);
+}
+

imm/src/model/CreateBindingResult.cc

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateBindingResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateBindingResult::CreateBindingResult() :
+	ServiceResult()
+{}
+
+CreateBindingResult::CreateBindingResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateBindingResult::~CreateBindingResult()
+{}
+
+void CreateBindingResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto bindingNode = value["Binding"];
+	if(!bindingNode["ProjectName"].isNull())
+		binding_.projectName = bindingNode["ProjectName"].asString();
+	if(!bindingNode["DatasetName"].isNull())
+		binding_.datasetName = bindingNode["DatasetName"].asString();
+	if(!bindingNode["URI"].isNull())
+		binding_.uRI = bindingNode["URI"].asString();
+	if(!bindingNode["State"].isNull())
+		binding_.state = bindingNode["State"].asString();
+	if(!bindingNode["Phase"].isNull())
+		binding_.phase = bindingNode["Phase"].asString();
+	if(!bindingNode["Detail"].isNull())
+		binding_.detail = bindingNode["Detail"].asString();
+	if(!bindingNode["CreateTime"].isNull())
+		binding_.createTime = bindingNode["CreateTime"].asString();
+	if(!bindingNode["UpdateTime"].isNull())
+		binding_.updateTime = bindingNode["UpdateTime"].asString();
+
+}
+
+CreateBindingResult::Binding CreateBindingResult::getBinding()const
+{
+	return binding_;
+}
+

imm/src/model/CreateDatasetRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateDatasetRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateDatasetRequest;
+
+CreateDatasetRequest::CreateDatasetRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateDataset") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateDatasetRequest::~CreateDatasetRequest() {}
+
+long CreateDatasetRequest::getDatasetMaxBindCount() const {
+  return datasetMaxBindCount_;
+}
+
+void CreateDatasetRequest::setDatasetMaxBindCount(long datasetMaxBindCount) {
+  datasetMaxBindCount_ = datasetMaxBindCount;
+  setParameter(std::string("DatasetMaxBindCount"), std::to_string(datasetMaxBindCount));
+}
+
+std::string CreateDatasetRequest::getDescription() const {
+  return description_;
+}
+
+void CreateDatasetRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+long CreateDatasetRequest::getDatasetMaxRelationCount() const {
+  return datasetMaxRelationCount_;
+}
+
+void CreateDatasetRequest::setDatasetMaxRelationCount(long datasetMaxRelationCount) {
+  datasetMaxRelationCount_ = datasetMaxRelationCount;
+  setParameter(std::string("DatasetMaxRelationCount"), std::to_string(datasetMaxRelationCount));
+}
+
+std::string CreateDatasetRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void CreateDatasetRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+long CreateDatasetRequest::getDatasetMaxFileCount() const {
+  return datasetMaxFileCount_;
+}
+
+void CreateDatasetRequest::setDatasetMaxFileCount(long datasetMaxFileCount) {
+  datasetMaxFileCount_ = datasetMaxFileCount;
+  setParameter(std::string("DatasetMaxFileCount"), std::to_string(datasetMaxFileCount));
+}
+
+std::string CreateDatasetRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateDatasetRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+long CreateDatasetRequest::getDatasetMaxEntityCount() const {
+  return datasetMaxEntityCount_;
+}
+
+void CreateDatasetRequest::setDatasetMaxEntityCount(long datasetMaxEntityCount) {
+  datasetMaxEntityCount_ = datasetMaxEntityCount;
+  setParameter(std::string("DatasetMaxEntityCount"), std::to_string(datasetMaxEntityCount));
+}
+
+std::string CreateDatasetRequest::getTemplateId() const {
+  return templateId_;
+}
+
+void CreateDatasetRequest::setTemplateId(const std::string &templateId) {
+  templateId_ = templateId;
+  setParameter(std::string("TemplateId"), templateId);
+}
+
+long CreateDatasetRequest::getDatasetMaxTotalFileSize() const {
+  return datasetMaxTotalFileSize_;
+}
+
+void CreateDatasetRequest::setDatasetMaxTotalFileSize(long datasetMaxTotalFileSize) {
+  datasetMaxTotalFileSize_ = datasetMaxTotalFileSize;
+  setParameter(std::string("DatasetMaxTotalFileSize"), std::to_string(datasetMaxTotalFileSize));
+}
+

imm/src/model/CreateDatasetResult.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateDatasetResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateDatasetResult::CreateDatasetResult() :
+	ServiceResult()
+{}
+
+CreateDatasetResult::CreateDatasetResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDatasetResult::~CreateDatasetResult()
+{}
+
+void CreateDatasetResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto datasetNode = value["Dataset"];
+	if(!datasetNode["ProjectName"].isNull())
+		dataset_.projectName = datasetNode["ProjectName"].asString();
+	if(!datasetNode["DatasetName"].isNull())
+		dataset_.datasetName = datasetNode["DatasetName"].asString();
+	if(!datasetNode["TemplateId"].isNull())
+		dataset_.templateId = datasetNode["TemplateId"].asString();
+	if(!datasetNode["CreateTime"].isNull())
+		dataset_.createTime = datasetNode["CreateTime"].asString();
+	if(!datasetNode["UpdateTime"].isNull())
+		dataset_.updateTime = datasetNode["UpdateTime"].asString();
+	if(!datasetNode["Description"].isNull())
+		dataset_.description = datasetNode["Description"].asString();
+	if(!datasetNode["DatasetMaxBindCount"].isNull())
+		dataset_.datasetMaxBindCount = std::stol(datasetNode["DatasetMaxBindCount"].asString());
+	if(!datasetNode["DatasetMaxFileCount"].isNull())
+		dataset_.datasetMaxFileCount = std::stol(datasetNode["DatasetMaxFileCount"].asString());
+	if(!datasetNode["DatasetMaxEntityCount"].isNull())
+		dataset_.datasetMaxEntityCount = std::stol(datasetNode["DatasetMaxEntityCount"].asString());
+	if(!datasetNode["DatasetMaxRelationCount"].isNull())
+		dataset_.datasetMaxRelationCount = std::stol(datasetNode["DatasetMaxRelationCount"].asString());
+	if(!datasetNode["DatasetMaxTotalFileSize"].isNull())
+		dataset_.datasetMaxTotalFileSize = std::stol(datasetNode["DatasetMaxTotalFileSize"].asString());
+	if(!datasetNode["BindCount"].isNull())
+		dataset_.bindCount = std::stol(datasetNode["BindCount"].asString());
+	if(!datasetNode["FileCount"].isNull())
+		dataset_.fileCount = std::stol(datasetNode["FileCount"].asString());
+	if(!datasetNode["TotalFileSize"].isNull())
+		dataset_.totalFileSize = std::stol(datasetNode["TotalFileSize"].asString());
+
+}
+
+CreateDatasetResult::Dataset CreateDatasetResult::getDataset()const
+{
+	return dataset_;
+}
+

imm/src/model/CreateDetectVideoLabelsTaskRequest.cc

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateDetectVideoLabelsTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateDetectVideoLabelsTaskRequest;
+
+CreateDetectVideoLabelsTaskRequest::CreateDetectVideoLabelsTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateDetectVideoLabelsTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateDetectVideoLabelsTaskRequest::~CreateDetectVideoLabelsTaskRequest() {}
+
+std::string CreateDetectVideoLabelsTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateDetectVideoLabelsTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+std::string CreateDetectVideoLabelsTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateDetectVideoLabelsTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateDetectVideoLabelsTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateDetectVideoLabelsTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateDetectVideoLabelsTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateDetectVideoLabelsTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+CreateDetectVideoLabelsTaskRequest::CredentialConfig CreateDetectVideoLabelsTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateDetectVideoLabelsTaskRequest::setCredentialConfig(const CreateDetectVideoLabelsTaskRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
+}
+
+std::map<std::string, std::string> CreateDetectVideoLabelsTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateDetectVideoLabelsTaskRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+
+std::string CreateDetectVideoLabelsTaskRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void CreateDetectVideoLabelsTaskRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/CreateDetectVideoLabelsTaskResult.cc

@@ -14,45 +14,45 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateVideoAnalyseTaskResult.h>
+#include <alibabacloud/imm/model/CreateDetectVideoLabelsTaskResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateVideoAnalyseTaskResult::CreateVideoAnalyseTaskResult() :
+CreateDetectVideoLabelsTaskResult::CreateDetectVideoLabelsTaskResult() :
 	ServiceResult()
 {}
 
-CreateVideoAnalyseTaskResult::CreateVideoAnalyseTaskResult(const std::string &payload) :
+CreateDetectVideoLabelsTaskResult::CreateDetectVideoLabelsTaskResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateVideoAnalyseTaskResult::~CreateVideoAnalyseTaskResult()
+CreateDetectVideoLabelsTaskResult::~CreateDetectVideoLabelsTaskResult()
 {}
 
-void CreateVideoAnalyseTaskResult::parse(const std::string &payload)
+void CreateDetectVideoLabelsTaskResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
 	if(!value["TaskId"].isNull())
 		taskId_ = value["TaskId"].asString();
-	if(!value["TaskType"].isNull())
-		taskType_ = value["TaskType"].asString();
 
 }
 
-std::string CreateVideoAnalyseTaskResult::getTaskId()const
+std::string CreateDetectVideoLabelsTaskResult::getTaskId()const
 {
 	return taskId_;
 }
 
-std::string CreateVideoAnalyseTaskResult::getTaskType()const
+std::string CreateDetectVideoLabelsTaskResult::getEventId()const
 {
-	return taskType_;
+	return eventId_;
 }
 

imm/src/model/CreateFigureClusteringTaskRequest.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/imm/model/CreateFigureClusteringTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateFigureClusteringTaskRequest;
+
+CreateFigureClusteringTaskRequest::CreateFigureClusteringTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateFigureClusteringTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateFigureClusteringTaskRequest::~CreateFigureClusteringTaskRequest() {}
+
+std::string CreateFigureClusteringTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateFigureClusteringTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+std::string CreateFigureClusteringTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateFigureClusteringTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateFigureClusteringTaskRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void CreateFigureClusteringTaskRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string CreateFigureClusteringTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateFigureClusteringTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateFigureClusteringTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateFigureClusteringTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+std::map<std::string, std::string> CreateFigureClusteringTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateFigureClusteringTaskRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+

imm/src/model/CreateFigureClusteringTaskResult.cc

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateFigureClusteringTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateFigureClusteringTaskResult::CreateFigureClusteringTaskResult() :
+	ServiceResult()
+{}
+
+CreateFigureClusteringTaskResult::CreateFigureClusteringTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateFigureClusteringTaskResult::~CreateFigureClusteringTaskResult()
+{}
+
+void CreateFigureClusteringTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = value["TaskId"].asString();
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
+
+}
+
+std::string CreateFigureClusteringTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string CreateFigureClusteringTaskResult::getEventId()const
+{
+	return eventId_;
+}
+

imm/src/model/CreateFigureClustersMergingTaskRequest.cc

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateFigureClustersMergingTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateFigureClustersMergingTaskRequest;
+
+CreateFigureClustersMergingTaskRequest::CreateFigureClustersMergingTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateFigureClustersMergingTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateFigureClustersMergingTaskRequest::~CreateFigureClustersMergingTaskRequest() {}
+
+std::string CreateFigureClustersMergingTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateFigureClustersMergingTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+std::string CreateFigureClustersMergingTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateFigureClustersMergingTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateFigureClustersMergingTaskRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void CreateFigureClustersMergingTaskRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string CreateFigureClustersMergingTaskRequest::getFrom() const {
+  return from_;
+}
+
+void CreateFigureClustersMergingTaskRequest::setFrom(const std::string &from) {
+  from_ = from;
+  setParameter(std::string("From"), from);
+}
+
+std::string CreateFigureClustersMergingTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateFigureClustersMergingTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateFigureClustersMergingTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateFigureClustersMergingTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+std::map<std::string, std::string> CreateFigureClustersMergingTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateFigureClustersMergingTaskRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+
+std::string CreateFigureClustersMergingTaskRequest::getTo() const {
+  return to_;
+}
+
+void CreateFigureClustersMergingTaskRequest::setTo(const std::string &to) {
+  to_ = to;
+  setParameter(std::string("To"), to);
+}
+

imm/src/model/CreateFigureClustersMergingTaskResult.cc

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateFigureClustersMergingTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateFigureClustersMergingTaskResult::CreateFigureClustersMergingTaskResult() :
+	ServiceResult()
+{}
+
+CreateFigureClustersMergingTaskResult::CreateFigureClustersMergingTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateFigureClustersMergingTaskResult::~CreateFigureClustersMergingTaskResult()
+{}
+
+void CreateFigureClustersMergingTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["TaskId"].isNull())
+		taskId_ = value["TaskId"].asString();
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
+
+}
+
+std::string CreateFigureClustersMergingTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string CreateFigureClustersMergingTaskResult::getEventId()const
+{
+	return eventId_;
+}
+

imm/src/model/CreateGrabFrameTaskRequest.cc

@@ -1,90 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateGrabFrameTaskRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateGrabFrameTaskRequest;
-
-CreateGrabFrameTaskRequest::CreateGrabFrameTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateGrabFrameTask") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateGrabFrameTaskRequest::~CreateGrabFrameTaskRequest() {}
-
-std::string CreateGrabFrameTaskRequest::getProject() const {
-  return project_;
-}
-
-void CreateGrabFrameTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateGrabFrameTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateGrabFrameTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateGrabFrameTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateGrabFrameTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-std::string CreateGrabFrameTaskRequest::getCustomMessage() const {
-  return customMessage_;
-}
-
-void CreateGrabFrameTaskRequest::setCustomMessage(const std::string &customMessage) {
-  customMessage_ = customMessage;
-  setParameter(std::string("CustomMessage"), customMessage);
-}
-
-std::string CreateGrabFrameTaskRequest::getNotifyTopicName() const {
-  return notifyTopicName_;
-}
-
-void CreateGrabFrameTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
-  notifyTopicName_ = notifyTopicName;
-  setParameter(std::string("NotifyTopicName"), notifyTopicName);
-}
-
-std::string CreateGrabFrameTaskRequest::getTargetList() const {
-  return targetList_;
-}
-
-void CreateGrabFrameTaskRequest::setTargetList(const std::string &targetList) {
-  targetList_ = targetList;
-  setParameter(std::string("TargetList"), targetList);
-}
-
-std::string CreateGrabFrameTaskRequest::getVideoUri() const {
-  return videoUri_;
-}
-
-void CreateGrabFrameTaskRequest::setVideoUri(const std::string &videoUri) {
-  videoUri_ = videoUri;
-  setParameter(std::string("VideoUri"), videoUri);
-}
-

imm/src/model/CreateGroupFacesJobRequest.cc

@@ -1,72 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateGroupFacesJobRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateGroupFacesJobRequest;
-
-CreateGroupFacesJobRequest::CreateGroupFacesJobRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateGroupFacesJob") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateGroupFacesJobRequest::~CreateGroupFacesJobRequest() {}
-
-std::string CreateGroupFacesJobRequest::getProject() const {
-  return project_;
-}
-
-void CreateGroupFacesJobRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateGroupFacesJobRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateGroupFacesJobRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateGroupFacesJobRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateGroupFacesJobRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-std::string CreateGroupFacesJobRequest::getNotifyTopicName() const {
-  return notifyTopicName_;
-}
-
-void CreateGroupFacesJobRequest::setNotifyTopicName(const std::string &notifyTopicName) {
-  notifyTopicName_ = notifyTopicName;
-  setParameter(std::string("NotifyTopicName"), notifyTopicName);
-}
-
-std::string CreateGroupFacesJobRequest::getSetId() const {
-  return setId_;
-}
-
-void CreateGroupFacesJobRequest::setSetId(const std::string &setId) {
-  setId_ = setId;
-  setParameter(std::string("SetId"), setId);
-}
-

imm/src/model/CreateImageModerationTaskRequest.cc

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateImageModerationTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateImageModerationTaskRequest;
+
+CreateImageModerationTaskRequest::CreateImageModerationTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateImageModerationTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateImageModerationTaskRequest::~CreateImageModerationTaskRequest() {}
+
+std::string CreateImageModerationTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateImageModerationTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+std::string CreateImageModerationTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateImageModerationTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateImageModerationTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateImageModerationTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateImageModerationTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateImageModerationTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+long CreateImageModerationTaskRequest::getMaxFrames() const {
+  return maxFrames_;
+}
+
+void CreateImageModerationTaskRequest::setMaxFrames(long maxFrames) {
+  maxFrames_ = maxFrames;
+  setParameter(std::string("MaxFrames"), std::to_string(maxFrames));
+}
+
+CreateImageModerationTaskRequest::CredentialConfig CreateImageModerationTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateImageModerationTaskRequest::setCredentialConfig(const CreateImageModerationTaskRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
+}
+
+std::string CreateImageModerationTaskRequest::getReviewer() const {
+  return reviewer_;
+}
+
+void CreateImageModerationTaskRequest::setReviewer(const std::string &reviewer) {
+  reviewer_ = reviewer;
+  setParameter(std::string("Reviewer"), reviewer);
+}
+
+std::map<std::string, std::string> CreateImageModerationTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateImageModerationTaskRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+
+std::string CreateImageModerationTaskRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void CreateImageModerationTaskRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+
+std::vector<CreateImageModerationTaskRequest::std::string> CreateImageModerationTaskRequest::getScenes() const {
+  return scenes_;
+}
+
+void CreateImageModerationTaskRequest::setScenes(const std::vector<CreateImageModerationTaskRequest::std::string> &scenes) {
+  scenes_ = scenes;
+  for(int dep1 = 0; dep1 != scenes.size(); dep1++) {
+    setParameter(std::string("Scenes") + "." + std::to_string(dep1 + 1), scenes[dep1]);
+  }
+}
+
+long CreateImageModerationTaskRequest::getInterval() const {
+  return interval_;
+}
+
+void CreateImageModerationTaskRequest::setInterval(long interval) {
+  interval_ = interval;
+  setParameter(std::string("Interval"), std::to_string(interval));
+}
+

imm/src/model/CreateImageModerationTaskResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateImageProcessTaskResult.h>
+#include <alibabacloud/imm/model/CreateImageModerationTaskResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateImageProcessTaskResult::CreateImageProcessTaskResult() :
+CreateImageModerationTaskResult::CreateImageModerationTaskResult() :
 	ServiceResult()
 {}
 
-CreateImageProcessTaskResult::CreateImageProcessTaskResult(const std::string &payload) :
+CreateImageModerationTaskResult::CreateImageModerationTaskResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateImageProcessTaskResult::~CreateImageProcessTaskResult()
+CreateImageModerationTaskResult::~CreateImageModerationTaskResult()
 {}
 
-void CreateImageProcessTaskResult::parse(const std::string &payload)
+void CreateImageModerationTaskResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
@@ -41,18 +41,18 @@ void CreateImageProcessTaskResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	if(!value["TaskId"].isNull())
 		taskId_ = value["TaskId"].asString();
-	if(!value["TaskType"].isNull())
-		taskType_ = value["TaskType"].asString();
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
 
 }
 
-std::string CreateImageProcessTaskResult::getTaskId()const
+std::string CreateImageModerationTaskResult::getTaskId()const
 {
 	return taskId_;
 }
 
-std::string CreateImageProcessTaskResult::getTaskType()const
+std::string CreateImageModerationTaskResult::getEventId()const
 {
-	return taskType_;
+	return eventId_;
 }
 

imm/src/model/CreateImageProcessTaskRequest.cc

@@ -1,81 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateImageProcessTaskRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateImageProcessTaskRequest;
-
-CreateImageProcessTaskRequest::CreateImageProcessTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateImageProcessTask") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateImageProcessTaskRequest::~CreateImageProcessTaskRequest() {}
-
-std::string CreateImageProcessTaskRequest::getProject() const {
-  return project_;
-}
-
-void CreateImageProcessTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateImageProcessTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateImageProcessTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateImageProcessTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateImageProcessTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-std::string CreateImageProcessTaskRequest::getNotifyTopicName() const {
-  return notifyTopicName_;
-}
-
-void CreateImageProcessTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
-  notifyTopicName_ = notifyTopicName;
-  setParameter(std::string("NotifyTopicName"), notifyTopicName);
-}
-
-std::string CreateImageProcessTaskRequest::getTargetList() const {
-  return targetList_;
-}
-
-void CreateImageProcessTaskRequest::setTargetList(const std::string &targetList) {
-  targetList_ = targetList;
-  setParameter(std::string("TargetList"), targetList);
-}
-
-std::string CreateImageProcessTaskRequest::getImageUri() const {
-  return imageUri_;
-}
-
-void CreateImageProcessTaskRequest::setImageUri(const std::string &imageUri) {
-  imageUri_ = imageUri;
-  setParameter(std::string("ImageUri"), imageUri);
-}
-

imm/src/model/CreateImageSplicingTaskRequest.cc

@@ -0,0 +1,182 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateImageSplicingTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateImageSplicingTaskRequest;
+
+CreateImageSplicingTaskRequest::CreateImageSplicingTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateImageSplicingTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateImageSplicingTaskRequest::~CreateImageSplicingTaskRequest() {}
+
+long CreateImageSplicingTaskRequest::getAlign() const {
+  return align_;
+}
+
+void CreateImageSplicingTaskRequest::setAlign(long align) {
+  align_ = align;
+  setParameter(std::string("Align"), std::to_string(align));
+}
+
+std::string CreateImageSplicingTaskRequest::getBackgroundColor() const {
+  return backgroundColor_;
+}
+
+void CreateImageSplicingTaskRequest::setBackgroundColor(const std::string &backgroundColor) {
+  backgroundColor_ = backgroundColor;
+  setParameter(std::string("BackgroundColor"), backgroundColor);
+}
+
+std::string CreateImageSplicingTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateImageSplicingTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateImageSplicingTaskRequest::getScaleType() const {
+  return scaleType_;
+}
+
+void CreateImageSplicingTaskRequest::setScaleType(const std::string &scaleType) {
+  scaleType_ = scaleType;
+  setParameter(std::string("ScaleType"), scaleType);
+}
+
+std::string CreateImageSplicingTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateImageSplicingTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+long CreateImageSplicingTaskRequest::getMargin() const {
+  return margin_;
+}
+
+void CreateImageSplicingTaskRequest::setMargin(long margin) {
+  margin_ = margin;
+  setParameter(std::string("Margin"), std::to_string(margin));
+}
+
+std::string CreateImageSplicingTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateImageSplicingTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+long CreateImageSplicingTaskRequest::getQuality() const {
+  return quality_;
+}
+
+void CreateImageSplicingTaskRequest::setQuality(long quality) {
+  quality_ = quality;
+  setParameter(std::string("Quality"), std::to_string(quality));
+}
+
+std::map<std::string, std::string> CreateImageSplicingTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateImageSplicingTaskRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+
+std::vector<CreateImageSplicingTaskRequest::Sources> CreateImageSplicingTaskRequest::getSources() const {
+  return sources_;
+}
+
+void CreateImageSplicingTaskRequest::setSources(const std::vector<CreateImageSplicingTaskRequest::Sources> &sources) {
+  sources_ = sources;
+  for(int dep1 = 0; dep1 != sources.size(); dep1++) {
+    setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".Rotate", std::to_string(sources[dep1].rotate));
+    setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".URI", sources[dep1].uRI);
+  }
+}
+
+std::string CreateImageSplicingTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateImageSplicingTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+std::string CreateImageSplicingTaskRequest::getTargetURI() const {
+  return targetURI_;
+}
+
+void CreateImageSplicingTaskRequest::setTargetURI(const std::string &targetURI) {
+  targetURI_ = targetURI;
+  setParameter(std::string("TargetURI"), targetURI);
+}
+
+std::string CreateImageSplicingTaskRequest::getImageFormat() const {
+  return imageFormat_;
+}
+
+void CreateImageSplicingTaskRequest::setImageFormat(const std::string &imageFormat) {
+  imageFormat_ = imageFormat;
+  setParameter(std::string("ImageFormat"), imageFormat);
+}
+
+std::string CreateImageSplicingTaskRequest::getDirection() const {
+  return direction_;
+}
+
+void CreateImageSplicingTaskRequest::setDirection(const std::string &direction) {
+  direction_ = direction;
+  setParameter(std::string("Direction"), direction);
+}
+
+long CreateImageSplicingTaskRequest::getPadding() const {
+  return padding_;
+}
+
+void CreateImageSplicingTaskRequest::setPadding(long padding) {
+  padding_ = padding;
+  setParameter(std::string("Padding"), std::to_string(padding));
+}
+
+CreateImageSplicingTaskRequest::CredentialConfig CreateImageSplicingTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateImageSplicingTaskRequest::setCredentialConfig(const CreateImageSplicingTaskRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
+}
+

imm/src/model/CreateImageSplicingTaskResult.cc

@@ -14,45 +14,45 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateVideoCompressTaskResult.h>
+#include <alibabacloud/imm/model/CreateImageSplicingTaskResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateVideoCompressTaskResult::CreateVideoCompressTaskResult() :
+CreateImageSplicingTaskResult::CreateImageSplicingTaskResult() :
 	ServiceResult()
 {}
 
-CreateVideoCompressTaskResult::CreateVideoCompressTaskResult(const std::string &payload) :
+CreateImageSplicingTaskResult::CreateImageSplicingTaskResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateVideoCompressTaskResult::~CreateVideoCompressTaskResult()
+CreateImageSplicingTaskResult::~CreateImageSplicingTaskResult()
 {}
 
-void CreateVideoCompressTaskResult::parse(const std::string &payload)
+void CreateImageSplicingTaskResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
 	if(!value["TaskId"].isNull())
 		taskId_ = value["TaskId"].asString();
-	if(!value["TaskType"].isNull())
-		taskType_ = value["TaskType"].asString();
 
 }
 
-std::string CreateVideoCompressTaskResult::getTaskId()const
+std::string CreateImageSplicingTaskResult::getTaskId()const
 {
 	return taskId_;
 }
 
-std::string CreateVideoCompressTaskResult::getTaskType()const
+std::string CreateImageSplicingTaskResult::getEventId()const
 {
-	return taskType_;
+	return eventId_;
 }
 

imm/src/model/CreateMediaComplexTaskRequest.cc

@@ -1,72 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateMediaComplexTaskRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateMediaComplexTaskRequest;
-
-CreateMediaComplexTaskRequest::CreateMediaComplexTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateMediaComplexTask") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateMediaComplexTaskRequest::~CreateMediaComplexTaskRequest() {}
-
-std::string CreateMediaComplexTaskRequest::getProject() const {
-  return project_;
-}
-
-void CreateMediaComplexTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateMediaComplexTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateMediaComplexTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateMediaComplexTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateMediaComplexTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-std::string CreateMediaComplexTaskRequest::getNotifyTopicName() const {
-  return notifyTopicName_;
-}
-
-void CreateMediaComplexTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
-  notifyTopicName_ = notifyTopicName;
-  setParameter(std::string("NotifyTopicName"), notifyTopicName);
-}
-
-std::string CreateMediaComplexTaskRequest::getParameters() const {
-  return parameters_;
-}
-
-void CreateMediaComplexTaskRequest::setParameters(const std::string &parameters) {
-  parameters_ = parameters;
-  setParameter(std::string("Parameters"), parameters);
-}
-

imm/src/model/CreateMediaConvertTaskRequest.cc

@@ -0,0 +1,207 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateMediaConvertTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateMediaConvertTaskRequest;
+
+CreateMediaConvertTaskRequest::CreateMediaConvertTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateMediaConvertTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateMediaConvertTaskRequest::~CreateMediaConvertTaskRequest() {}
+
+std::vector<CreateMediaConvertTaskRequest::Sources> CreateMediaConvertTaskRequest::getSources() const {
+  return sources_;
+}
+
+void CreateMediaConvertTaskRequest::setSources(const std::vector<CreateMediaConvertTaskRequest::Sources> &sources) {
+  sources_ = sources;
+  for(int dep1 = 0; dep1 != sources.size(); dep1++) {
+    setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".Duration", std::to_string(sources[dep1].duration));
+    for(int dep2 = 0; dep2 != sources[dep1].subtitles.size(); dep2++) {
+      setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".Subtitles." + std::to_string(dep2 + 1) + ".TimeOffset", std::to_string(sources[dep1].subtitles[dep2].timeOffset));
+      setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".Subtitles." + std::to_string(dep2 + 1) + ".Language", sources[dep1].subtitles[dep2].language);
+      setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".Subtitles." + std::to_string(dep2 + 1) + ".URI", sources[dep1].subtitles[dep2].uRI);
+    }
+    setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".StartTime", std::to_string(sources[dep1].startTime));
+    setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".URI", sources[dep1].uRI);
+  }
+}
+
+std::vector<CreateMediaConvertTaskRequest::Targets> CreateMediaConvertTaskRequest::getTargets() const {
+  return targets_;
+}
+
+void CreateMediaConvertTaskRequest::setTargets(const std::vector<CreateMediaConvertTaskRequest::Targets> &targets) {
+  targets_ = targets;
+  for(int dep1 = 0; dep1 != targets.size(); dep1++) {
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Container", targets[dep1].container);
+    for(int dep2 = 0; dep2 != targets[dep1].image.snapshots.size(); dep2++) {
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Snapshots." + std::to_string(dep2 + 1) + ".Number", std::to_string(targets[dep1].image.snapshots[dep2].number));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Snapshots." + std::to_string(dep2 + 1) + ".Format", targets[dep1].image.snapshots[dep2].format);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Snapshots." + std::to_string(dep2 + 1) + ".Width", std::to_string(targets[dep1].image.snapshots[dep2].width));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Snapshots." + std::to_string(dep2 + 1) + ".Interval", std::to_string(targets[dep1].image.snapshots[dep2].interval));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Snapshots." + std::to_string(dep2 + 1) + ".StartTime", std::to_string(targets[dep1].image.snapshots[dep2].startTime));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Snapshots." + std::to_string(dep2 + 1) + ".ScaleType", targets[dep1].image.snapshots[dep2].scaleType);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Snapshots." + std::to_string(dep2 + 1) + ".URI", targets[dep1].image.snapshots[dep2].uRI);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Snapshots." + std::to_string(dep2 + 1) + ".Height", std::to_string(targets[dep1].image.snapshots[dep2].height));
+    }
+    for(int dep2 = 0; dep2 != targets[dep1].image.sprites.size(); dep2++) {
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".TileHeight", std::to_string(targets[dep1].image.sprites[dep2].tileHeight));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".Number", std::to_string(targets[dep1].image.sprites[dep2].number));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".Pad", std::to_string(targets[dep1].image.sprites[dep2].pad));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".Margin", std::to_string(targets[dep1].image.sprites[dep2].margin));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".ScaleWidth", std::to_string(targets[dep1].image.sprites[dep2].scaleWidth));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".Format", targets[dep1].image.sprites[dep2].format);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".Interval", std::to_string(targets[dep1].image.sprites[dep2].interval));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".StartTime", std::to_string(targets[dep1].image.sprites[dep2].startTime));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".ScaleType", targets[dep1].image.sprites[dep2].scaleType);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".ScaleHeight", std::to_string(targets[dep1].image.sprites[dep2].scaleHeight));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".URI", targets[dep1].image.sprites[dep2].uRI);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Sprites." + std::to_string(dep2 + 1) + ".TileWidth", std::to_string(targets[dep1].image.sprites[dep2].tileWidth));
+    }
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Encryption.ProtectionSystem", targets[dep1].encryption.protectionSystem);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Segment.Duration", std::to_string(targets[dep1].segment.duration));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Segment.Format", targets[dep1].segment.format);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Segment.StartNumber", std::to_string(targets[dep1].segment.startNumber));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Subtitle.DisableSubtitle", targets[dep1].subtitle.disableSubtitle ? "true" : "false");
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Subtitle.ExtractSubtitle.Format", targets[dep1].subtitle.extractSubtitle.format);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Subtitle.ExtractSubtitle.URI", targets[dep1].subtitle.extractSubtitle.uRI);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Preset.Name", targets[dep1].preset.name);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Preset.Type", targets[dep1].preset.type);
+    for(int dep2 = 0; dep2 != targets[dep1].video.filterVideo.delogos.size(); dep2++) {
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Delogos." + std::to_string(dep2 + 1) + ".Duration", std::to_string(targets[dep1].video.filterVideo.delogos[dep2].duration));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Delogos." + std::to_string(dep2 + 1) + ".Dx", std::to_string(targets[dep1].video.filterVideo.delogos[dep2].dx));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Delogos." + std::to_string(dep2 + 1) + ".Dy", std::to_string(targets[dep1].video.filterVideo.delogos[dep2].dy));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Delogos." + std::to_string(dep2 + 1) + ".Width", std::to_string(targets[dep1].video.filterVideo.delogos[dep2].width));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Delogos." + std::to_string(dep2 + 1) + ".ReferPos", targets[dep1].video.filterVideo.delogos[dep2].referPos);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Delogos." + std::to_string(dep2 + 1) + ".StartTime", std::to_string(targets[dep1].video.filterVideo.delogos[dep2].startTime));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Delogos." + std::to_string(dep2 + 1) + ".Height", std::to_string(targets[dep1].video.filterVideo.delogos[dep2].height));
+    }
+    for(int dep2 = 0; dep2 != targets[dep1].video.filterVideo.watermarks.size(); dep2++) {
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".FontApha", std::to_string(targets[dep1].video.filterVideo.watermarks[dep2].fontApha));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".FontSize", std::to_string(targets[dep1].video.filterVideo.watermarks[dep2].fontSize));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".StartTime", std::to_string(targets[dep1].video.filterVideo.watermarks[dep2].startTime));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".Type", targets[dep1].video.filterVideo.watermarks[dep2].type);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".FontName", targets[dep1].video.filterVideo.watermarks[dep2].fontName);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".URI", targets[dep1].video.filterVideo.watermarks[dep2].uRI);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".Content", targets[dep1].video.filterVideo.watermarks[dep2].content);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".BorderColor", targets[dep1].video.filterVideo.watermarks[dep2].borderColor);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".Duration", std::to_string(targets[dep1].video.filterVideo.watermarks[dep2].duration));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".Dx", std::to_string(targets[dep1].video.filterVideo.watermarks[dep2].dx));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".Dy", std::to_string(targets[dep1].video.filterVideo.watermarks[dep2].dy));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".BorderWidth", std::to_string(targets[dep1].video.filterVideo.watermarks[dep2].borderWidth));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".Width", std::to_string(targets[dep1].video.filterVideo.watermarks[dep2].width));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".FontColor", targets[dep1].video.filterVideo.watermarks[dep2].fontColor);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".ReferPos", targets[dep1].video.filterVideo.watermarks[dep2].referPos);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.FilterVideo.Watermarks." + std::to_string(dep2 + 1) + ".Height", std::to_string(targets[dep1].video.filterVideo.watermarks[dep2].height));
+    }
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.DisableVideo", targets[dep1].video.disableVideo ? "true" : "false");
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.ResolutionOption", targets[dep1].video.transcodeVideo.resolutionOption);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.GOPSize", std::to_string(targets[dep1].video.transcodeVideo.gOPSize));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.PixelFormat", targets[dep1].video.transcodeVideo.pixelFormat);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.FrameRate", std::to_string(targets[dep1].video.transcodeVideo.frameRate));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.Rotation", std::to_string(targets[dep1].video.transcodeVideo.rotation));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.Bitrate", std::to_string(targets[dep1].video.transcodeVideo.bitrate));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.BufferSize", std::to_string(targets[dep1].video.transcodeVideo.bufferSize));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.Resolution", targets[dep1].video.transcodeVideo.resolution);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.BFrames", std::to_string(targets[dep1].video.transcodeVideo.bFrames));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.MaxBitrate", std::to_string(targets[dep1].video.transcodeVideo.maxBitrate));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.Codec", targets[dep1].video.transcodeVideo.codec);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.BitrateOption", targets[dep1].video.transcodeVideo.bitrateOption);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.Refs", std::to_string(targets[dep1].video.transcodeVideo.refs));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.CRF", std::to_string(targets[dep1].video.transcodeVideo.cRF));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.ScaleType", targets[dep1].video.transcodeVideo.scaleType);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.FrameRateOption", targets[dep1].video.transcodeVideo.frameRateOption);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.TranscodeVideo.AdaptiveResolutionDirection", targets[dep1].video.transcodeVideo.adaptiveResolutionDirection ? "true" : "false");
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.DisableAudio", targets[dep1].audio.disableAudio ? "true" : "false");
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.TranscodeAudio.Codec", targets[dep1].audio.transcodeAudio.codec);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.TranscodeAudio.BitrateOption", targets[dep1].audio.transcodeAudio.bitrateOption);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.TranscodeAudio.Channel", std::to_string(targets[dep1].audio.transcodeAudio.channel));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.TranscodeAudio.Bitrate", std::to_string(targets[dep1].audio.transcodeAudio.bitrate));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.TranscodeAudio.SampleRateOption", targets[dep1].audio.transcodeAudio.sampleRateOption);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.TranscodeAudio.Quality", std::to_string(targets[dep1].audio.transcodeAudio.quality));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.TranscodeAudio.SampleRate", std::to_string(targets[dep1].audio.transcodeAudio.sampleRate));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.FilterAudio.Mixing", targets[dep1].audio.filterAudio.mixing ? "true" : "false");
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".URI", targets[dep1].uRI);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Speed", std::to_string(targets[dep1].speed));
+  }
+}
+
+std::string CreateMediaConvertTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateMediaConvertTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+std::string CreateMediaConvertTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateMediaConvertTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateMediaConvertTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateMediaConvertTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateMediaConvertTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateMediaConvertTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+CreateMediaConvertTaskRequest::CredentialConfig CreateMediaConvertTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateMediaConvertTaskRequest::setCredentialConfig(const CreateMediaConvertTaskRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
+}
+
+std::map<std::string, std::string> CreateMediaConvertTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateMediaConvertTaskRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+

imm/src/model/CreateMediaConvertTaskResult.cc

@@ -14,45 +14,45 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateMediaComplexTaskResult.h>
+#include <alibabacloud/imm/model/CreateMediaConvertTaskResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateMediaComplexTaskResult::CreateMediaComplexTaskResult() :
+CreateMediaConvertTaskResult::CreateMediaConvertTaskResult() :
 	ServiceResult()
 {}
 
-CreateMediaComplexTaskResult::CreateMediaComplexTaskResult(const std::string &payload) :
+CreateMediaConvertTaskResult::CreateMediaConvertTaskResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateMediaComplexTaskResult::~CreateMediaComplexTaskResult()
+CreateMediaConvertTaskResult::~CreateMediaConvertTaskResult()
 {}
 
-void CreateMediaComplexTaskResult::parse(const std::string &payload)
+void CreateMediaConvertTaskResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
 	if(!value["TaskId"].isNull())
 		taskId_ = value["TaskId"].asString();
-	if(!value["TaskType"].isNull())
-		taskType_ = value["TaskType"].asString();
 
 }
 
-std::string CreateMediaComplexTaskResult::getTaskId()const
+std::string CreateMediaConvertTaskResult::getTaskId()const
 {
 	return taskId_;
 }
 
-std::string CreateMediaComplexTaskResult::getTaskType()const
+std::string CreateMediaConvertTaskResult::getEventId()const
 {
-	return taskType_;
+	return eventId_;
 }
 

imm/src/model/CreateMergeFaceGroupsJobRequest.cc

@@ -1,99 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateMergeFaceGroupsJobRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateMergeFaceGroupsJobRequest;
-
-CreateMergeFaceGroupsJobRequest::CreateMergeFaceGroupsJobRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateMergeFaceGroupsJob") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateMergeFaceGroupsJobRequest::~CreateMergeFaceGroupsJobRequest() {}
-
-std::string CreateMergeFaceGroupsJobRequest::getProject() const {
-  return project_;
-}
-
-void CreateMergeFaceGroupsJobRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateMergeFaceGroupsJobRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateMergeFaceGroupsJobRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateMergeFaceGroupsJobRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateMergeFaceGroupsJobRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-std::string CreateMergeFaceGroupsJobRequest::getCustomMessage() const {
-  return customMessage_;
-}
-
-void CreateMergeFaceGroupsJobRequest::setCustomMessage(const std::string &customMessage) {
-  customMessage_ = customMessage;
-  setParameter(std::string("CustomMessage"), customMessage);
-}
-
-std::string CreateMergeFaceGroupsJobRequest::getGroupIdFrom() const {
-  return groupIdFrom_;
-}
-
-void CreateMergeFaceGroupsJobRequest::setGroupIdFrom(const std::string &groupIdFrom) {
-  groupIdFrom_ = groupIdFrom;
-  setParameter(std::string("GroupIdFrom"), groupIdFrom);
-}
-
-std::string CreateMergeFaceGroupsJobRequest::getNotifyTopicName() const {
-  return notifyTopicName_;
-}
-
-void CreateMergeFaceGroupsJobRequest::setNotifyTopicName(const std::string &notifyTopicName) {
-  notifyTopicName_ = notifyTopicName;
-  setParameter(std::string("NotifyTopicName"), notifyTopicName);
-}
-
-std::string CreateMergeFaceGroupsJobRequest::getGroupIdTo() const {
-  return groupIdTo_;
-}
-
-void CreateMergeFaceGroupsJobRequest::setGroupIdTo(const std::string &groupIdTo) {
-  groupIdTo_ = groupIdTo;
-  setParameter(std::string("GroupIdTo"), groupIdTo);
-}
-
-std::string CreateMergeFaceGroupsJobRequest::getSetId() const {
-  return setId_;
-}
-
-void CreateMergeFaceGroupsJobRequest::setSetId(const std::string &setId) {
-  setId_ = setId;
-  setParameter(std::string("SetId"), setId);
-}
-

imm/src/model/CreateMergeFaceGroupsJobResult.cc

@@ -1,79 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateMergeFaceGroupsJobResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-CreateMergeFaceGroupsJobResult::CreateMergeFaceGroupsJobResult() :
-	ServiceResult()
-{}
-
-CreateMergeFaceGroupsJobResult::CreateMergeFaceGroupsJobResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-CreateMergeFaceGroupsJobResult::~CreateMergeFaceGroupsJobResult()
-{}
-
-void CreateMergeFaceGroupsJobResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	if(!value["GroupIdFrom"].isNull())
-		groupIdFrom_ = value["GroupIdFrom"].asString();
-	if(!value["JobType"].isNull())
-		jobType_ = value["JobType"].asString();
-	if(!value["SetId"].isNull())
-		setId_ = value["SetId"].asString();
-	if(!value["GroupIdTo"].isNull())
-		groupIdTo_ = value["GroupIdTo"].asString();
-	if(!value["JobId"].isNull())
-		jobId_ = value["JobId"].asString();
-
-}
-
-std::string CreateMergeFaceGroupsJobResult::getGroupIdFrom()const
-{
-	return groupIdFrom_;
-}
-
-std::string CreateMergeFaceGroupsJobResult::getJobType()const
-{
-	return jobType_;
-}
-
-std::string CreateMergeFaceGroupsJobResult::getSetId()const
-{
-	return setId_;
-}
-
-std::string CreateMergeFaceGroupsJobResult::getGroupIdTo()const
-{
-	return groupIdTo_;
-}
-
-std::string CreateMergeFaceGroupsJobResult::getJobId()const
-{
-	return jobId_;
-}
-

imm/src/model/CreateOfficeConversionTaskRequest.cc

@@ -19,64 +19,28 @@
 using AlibabaCloud::Imm::Model::CreateOfficeConversionTaskRequest;
 
 CreateOfficeConversionTaskRequest::CreateOfficeConversionTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateOfficeConversionTask") {
+    : RpcServiceRequest("imm", "2020-09-30", "CreateOfficeConversionTask") {
   setMethod(HttpRequest::Method::Post);
 }
 
 CreateOfficeConversionTaskRequest::~CreateOfficeConversionTaskRequest() {}
 
-std::string CreateOfficeConversionTaskRequest::getSrcType() const {
-  return srcType_;
+long CreateOfficeConversionTaskRequest::getSheetCount() const {
+  return sheetCount_;
 }
 
-void CreateOfficeConversionTaskRequest::setSrcType(const std::string &srcType) {
-  srcType_ = srcType;
-  setParameter(std::string("SrcType"), srcType);
+void CreateOfficeConversionTaskRequest::setSheetCount(long sheetCount) {
+  sheetCount_ = sheetCount;
+  setParameter(std::string("SheetCount"), std::to_string(sheetCount));
 }
 
-std::string CreateOfficeConversionTaskRequest::getProject() const {
-  return project_;
+bool CreateOfficeConversionTaskRequest::getShowComments() const {
+  return showComments_;
 }
 
-void CreateOfficeConversionTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateOfficeConversionTaskRequest::getIdempotentToken() const {
-  return idempotentToken_;
-}
-
-void CreateOfficeConversionTaskRequest::setIdempotentToken(const std::string &idempotentToken) {
-  idempotentToken_ = idempotentToken;
-  setParameter(std::string("IdempotentToken"), idempotentToken);
-}
-
-bool CreateOfficeConversionTaskRequest::getPdfVector() const {
-  return pdfVector_;
-}
-
-void CreateOfficeConversionTaskRequest::setPdfVector(bool pdfVector) {
-  pdfVector_ = pdfVector;
-  setParameter(std::string("PdfVector"), pdfVector ? "true" : "false");
-}
-
-std::string CreateOfficeConversionTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateOfficeConversionTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateOfficeConversionTaskRequest::getUserData() const {
-  return userData_;
-}
-
-void CreateOfficeConversionTaskRequest::setUserData(const std::string &userData) {
-  userData_ = userData;
-  setParameter(std::string("UserData"), userData);
+void CreateOfficeConversionTaskRequest::setShowComments(bool showComments) {
+  showComments_ = showComments;
+  setParameter(std::string("ShowComments"), showComments ? "true" : "false");
 }
 
 std::string CreateOfficeConversionTaskRequest::getPassword() const {
@@ -88,13 +52,13 @@ void CreateOfficeConversionTaskRequest::setPassword(const std::string &password)
   setParameter(std::string("Password"), password);
 }
 
-long CreateOfficeConversionTaskRequest::getStartPage() const {
-  return startPage_;
+std::string CreateOfficeConversionTaskRequest::getPages() const {
+  return pages_;
 }
 
-void CreateOfficeConversionTaskRequest::setStartPage(long startPage) {
-  startPage_ = startPage;
-  setParameter(std::string("StartPage"), std::to_string(startPage));
+void CreateOfficeConversionTaskRequest::setPages(const std::string &pages) {
+  pages_ = pages;
+  setParameter(std::string("Pages"), pages);
 }
 
 std::string CreateOfficeConversionTaskRequest::getNotifyEndpoint() const {
@@ -106,22 +70,22 @@ void CreateOfficeConversionTaskRequest::setNotifyEndpoint(const std::string &not
   setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
 }
 
-bool CreateOfficeConversionTaskRequest::getFitToPagesWide() const {
-  return fitToPagesWide_;
+std::string CreateOfficeConversionTaskRequest::getSourceType() const {
+  return sourceType_;
 }
 
-void CreateOfficeConversionTaskRequest::setFitToPagesWide(bool fitToPagesWide) {
-  fitToPagesWide_ = fitToPagesWide;
-  setParameter(std::string("FitToPagesWide"), fitToPagesWide ? "true" : "false");
+void CreateOfficeConversionTaskRequest::setSourceType(const std::string &sourceType) {
+  sourceType_ = sourceType;
+  setParameter(std::string("SourceType"), sourceType);
 }
 
-std::string CreateOfficeConversionTaskRequest::getTgtFilePrefix() const {
-  return tgtFilePrefix_;
+std::string CreateOfficeConversionTaskRequest::getProjectName() const {
+  return projectName_;
 }
 
-void CreateOfficeConversionTaskRequest::setTgtFilePrefix(const std::string &tgtFilePrefix) {
-  tgtFilePrefix_ = tgtFilePrefix;
-  setParameter(std::string("TgtFilePrefix"), tgtFilePrefix);
+void CreateOfficeConversionTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
 }
 
 std::string CreateOfficeConversionTaskRequest::getNotifyTopicName() const {
@@ -133,40 +97,13 @@ void CreateOfficeConversionTaskRequest::setNotifyTopicName(const std::string &no
   setParameter(std::string("NotifyTopicName"), notifyTopicName);
 }
 
-std::string CreateOfficeConversionTaskRequest::getModelId() const {
-  return modelId_;
+bool CreateOfficeConversionTaskRequest::getFitToHeight() const {
+  return fitToHeight_;
 }
 
-void CreateOfficeConversionTaskRequest::setModelId(const std::string &modelId) {
-  modelId_ = modelId;
-  setParameter(std::string("ModelId"), modelId);
-}
-
-int CreateOfficeConversionTaskRequest::getDisplayDpi() const {
-  return displayDpi_;
-}
-
-void CreateOfficeConversionTaskRequest::setDisplayDpi(int displayDpi) {
-  displayDpi_ = displayDpi;
-  setParameter(std::string("DisplayDpi"), std::to_string(displayDpi));
-}
-
-long CreateOfficeConversionTaskRequest::getMaxSheetRow() const {
-  return maxSheetRow_;
-}
-
-void CreateOfficeConversionTaskRequest::setMaxSheetRow(long maxSheetRow) {
-  maxSheetRow_ = maxSheetRow;
-  setParameter(std::string("MaxSheetRow"), std::to_string(maxSheetRow));
-}
-
-long CreateOfficeConversionTaskRequest::getMaxSheetCount() const {
-  return maxSheetCount_;
-}
-
-void CreateOfficeConversionTaskRequest::setMaxSheetCount(long maxSheetCount) {
-  maxSheetCount_ = maxSheetCount;
-  setParameter(std::string("MaxSheetCount"), std::to_string(maxSheetCount));
+void CreateOfficeConversionTaskRequest::setFitToHeight(bool fitToHeight) {
+  fitToHeight_ = fitToHeight;
+  setParameter(std::string("FitToHeight"), fitToHeight ? "true" : "false");
 }
 
 long CreateOfficeConversionTaskRequest::getEndPage() const {
@@ -178,84 +115,212 @@ void CreateOfficeConversionTaskRequest::setEndPage(long endPage) {
   setParameter(std::string("EndPage"), std::to_string(endPage));
 }
 
-std::string CreateOfficeConversionTaskRequest::getTgtFileSuffix() const {
-  return tgtFileSuffix_;
+bool CreateOfficeConversionTaskRequest::getFitToWidth() const {
+  return fitToWidth_;
 }
 
-void CreateOfficeConversionTaskRequest::setTgtFileSuffix(const std::string &tgtFileSuffix) {
-  tgtFileSuffix_ = tgtFileSuffix;
-  setParameter(std::string("TgtFileSuffix"), tgtFileSuffix);
+void CreateOfficeConversionTaskRequest::setFitToWidth(bool fitToWidth) {
+  fitToWidth_ = fitToWidth;
+  setParameter(std::string("FitToWidth"), fitToWidth ? "true" : "false");
 }
 
-bool CreateOfficeConversionTaskRequest::getSheetOnePage() const {
-  return sheetOnePage_;
+long CreateOfficeConversionTaskRequest::getQuality() const {
+  return quality_;
 }
 
-void CreateOfficeConversionTaskRequest::setSheetOnePage(bool sheetOnePage) {
-  sheetOnePage_ = sheetOnePage;
-  setParameter(std::string("SheetOnePage"), sheetOnePage ? "true" : "false");
+void CreateOfficeConversionTaskRequest::setQuality(long quality) {
+  quality_ = quality;
+  setParameter(std::string("Quality"), std::to_string(quality));
 }
 
-long CreateOfficeConversionTaskRequest::getMaxSheetCol() const {
-  return maxSheetCol_;
+std::map<std::string, std::string> CreateOfficeConversionTaskRequest::getTags() const {
+  return tags_;
 }
 
-void CreateOfficeConversionTaskRequest::setMaxSheetCol(long maxSheetCol) {
-  maxSheetCol_ = maxSheetCol;
-  setParameter(std::string("MaxSheetCol"), std::to_string(maxSheetCol));
+void CreateOfficeConversionTaskRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
 }
 
-std::string CreateOfficeConversionTaskRequest::getTgtType() const {
-  return tgtType_;
+std::string CreateOfficeConversionTaskRequest::getSourceURI() const {
+  return sourceURI_;
 }
 
-void CreateOfficeConversionTaskRequest::setTgtType(const std::string &tgtType) {
-  tgtType_ = tgtType;
-  setParameter(std::string("TgtType"), tgtType);
+void CreateOfficeConversionTaskRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
 }
 
-bool CreateOfficeConversionTaskRequest::getHidecomments() const {
-  return hidecomments_;
+long CreateOfficeConversionTaskRequest::getSheetIndex() const {
+  return sheetIndex_;
 }
 
-void CreateOfficeConversionTaskRequest::setHidecomments(bool hidecomments) {
-  hidecomments_ = hidecomments;
-  setParameter(std::string("Hidecomments"), hidecomments ? "true" : "false");
+void CreateOfficeConversionTaskRequest::setSheetIndex(long sheetIndex) {
+  sheetIndex_ = sheetIndex;
+  setParameter(std::string("SheetIndex"), std::to_string(sheetIndex));
 }
 
-bool CreateOfficeConversionTaskRequest::getFitToPagesTall() const {
-  return fitToPagesTall_;
+bool CreateOfficeConversionTaskRequest::getHoldLineFeed() const {
+  return holdLineFeed_;
 }
 
-void CreateOfficeConversionTaskRequest::setFitToPagesTall(bool fitToPagesTall) {
-  fitToPagesTall_ = fitToPagesTall;
-  setParameter(std::string("FitToPagesTall"), fitToPagesTall ? "true" : "false");
+void CreateOfficeConversionTaskRequest::setHoldLineFeed(bool holdLineFeed) {
+  holdLineFeed_ = holdLineFeed;
+  setParameter(std::string("HoldLineFeed"), holdLineFeed ? "true" : "false");
 }
 
-std::string CreateOfficeConversionTaskRequest::getSrcUri() const {
-  return srcUri_;
+bool CreateOfficeConversionTaskRequest::getLongText() const {
+  return longText_;
 }
 
-void CreateOfficeConversionTaskRequest::setSrcUri(const std::string &srcUri) {
-  srcUri_ = srcUri;
-  setParameter(std::string("SrcUri"), srcUri);
+void CreateOfficeConversionTaskRequest::setLongText(bool longText) {
+  longText_ = longText;
+  setParameter(std::string("LongText"), longText ? "true" : "false");
 }
 
-std::string CreateOfficeConversionTaskRequest::getTgtFilePages() const {
-  return tgtFilePages_;
+std::string CreateOfficeConversionTaskRequest::getTargetType() const {
+  return targetType_;
 }
 
-void CreateOfficeConversionTaskRequest::setTgtFilePages(const std::string &tgtFilePages) {
-  tgtFilePages_ = tgtFilePages;
-  setParameter(std::string("TgtFilePages"), tgtFilePages);
+void CreateOfficeConversionTaskRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
 }
 
-std::string CreateOfficeConversionTaskRequest::getTgtUri() const {
-  return tgtUri_;
+CreateOfficeConversionTaskRequest::TrimPolicy CreateOfficeConversionTaskRequest::getTrimPolicy() const {
+  return trimPolicy_;
 }
 
-void CreateOfficeConversionTaskRequest::setTgtUri(const std::string &tgtUri) {
-  tgtUri_ = tgtUri;
-  setParameter(std::string("TgtUri"), tgtUri);
+void CreateOfficeConversionTaskRequest::setTrimPolicy(const CreateOfficeConversionTaskRequest::TrimPolicy &trimPolicy) {
+  trimPolicy_ = trimPolicy;
+  setParameter(std::string("TrimPolicy") + ".DisableDeleteUnusedPicture", trimPolicy.disableDeleteUnusedPicture ? "true" : "false");
+  setParameter(std::string("TrimPolicy") + ".DisableDeleteRepeatedStyle", trimPolicy.disableDeleteRepeatedStyle ? "true" : "false");
+  setParameter(std::string("TrimPolicy") + ".DisableDeleteUnusedShape", trimPolicy.disableDeleteUnusedShape ? "true" : "false");
+  setParameter(std::string("TrimPolicy") + ".DisableDeleteEmptyCell", trimPolicy.disableDeleteEmptyCell ? "true" : "false");
+}
+
+long CreateOfficeConversionTaskRequest::getMaxSheetColumn() const {
+  return maxSheetColumn_;
+}
+
+void CreateOfficeConversionTaskRequest::setMaxSheetColumn(long maxSheetColumn) {
+  maxSheetColumn_ = maxSheetColumn;
+  setParameter(std::string("MaxSheetColumn"), std::to_string(maxSheetColumn));
+}
+
+bool CreateOfficeConversionTaskRequest::getFirstPage() const {
+  return firstPage_;
+}
+
+void CreateOfficeConversionTaskRequest::setFirstPage(bool firstPage) {
+  firstPage_ = firstPage;
+  setParameter(std::string("FirstPage"), firstPage ? "true" : "false");
+}
+
+bool CreateOfficeConversionTaskRequest::getPaperHorizontal() const {
+  return paperHorizontal_;
+}
+
+void CreateOfficeConversionTaskRequest::setPaperHorizontal(bool paperHorizontal) {
+  paperHorizontal_ = paperHorizontal;
+  setParameter(std::string("PaperHorizontal"), paperHorizontal ? "true" : "false");
+}
+
+std::string CreateOfficeConversionTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateOfficeConversionTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+long CreateOfficeConversionTaskRequest::getScalePercentage() const {
+  return scalePercentage_;
+}
+
+void CreateOfficeConversionTaskRequest::setScalePercentage(long scalePercentage) {
+  scalePercentage_ = scalePercentage;
+  setParameter(std::string("ScalePercentage"), std::to_string(scalePercentage));
+}
+
+long CreateOfficeConversionTaskRequest::getStartPage() const {
+  return startPage_;
+}
+
+void CreateOfficeConversionTaskRequest::setStartPage(long startPage) {
+  startPage_ = startPage;
+  setParameter(std::string("StartPage"), std::to_string(startPage));
+}
+
+std::string CreateOfficeConversionTaskRequest::getTargetURIPrefix() const {
+  return targetURIPrefix_;
+}
+
+void CreateOfficeConversionTaskRequest::setTargetURIPrefix(const std::string &targetURIPrefix) {
+  targetURIPrefix_ = targetURIPrefix;
+  setParameter(std::string("TargetURIPrefix"), targetURIPrefix);
+}
+
+std::string CreateOfficeConversionTaskRequest::getTargetURI() const {
+  return targetURI_;
+}
+
+void CreateOfficeConversionTaskRequest::setTargetURI(const std::string &targetURI) {
+  targetURI_ = targetURI;
+  setParameter(std::string("TargetURI"), targetURI);
+}
+
+std::string CreateOfficeConversionTaskRequest::getPaperSize() const {
+  return paperSize_;
+}
+
+void CreateOfficeConversionTaskRequest::setPaperSize(const std::string &paperSize) {
+  paperSize_ = paperSize;
+  setParameter(std::string("PaperSize"), paperSize);
+}
+
+long CreateOfficeConversionTaskRequest::getImageDPI() const {
+  return imageDPI_;
+}
+
+void CreateOfficeConversionTaskRequest::setImageDPI(long imageDPI) {
+  imageDPI_ = imageDPI;
+  setParameter(std::string("ImageDPI"), std::to_string(imageDPI));
+}
+
+bool CreateOfficeConversionTaskRequest::getLongPicture() const {
+  return longPicture_;
+}
+
+void CreateOfficeConversionTaskRequest::setLongPicture(bool longPicture) {
+  longPicture_ = longPicture;
+  setParameter(std::string("LongPicture"), longPicture ? "true" : "false");
+}
+
+long CreateOfficeConversionTaskRequest::getMaxSheetRow() const {
+  return maxSheetRow_;
+}
+
+void CreateOfficeConversionTaskRequest::setMaxSheetRow(long maxSheetRow) {
+  maxSheetRow_ = maxSheetRow;
+  setParameter(std::string("MaxSheetRow"), std::to_string(maxSheetRow));
+}
+
+CreateOfficeConversionTaskRequest::CredentialConfig CreateOfficeConversionTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateOfficeConversionTaskRequest::setCredentialConfig(const CreateOfficeConversionTaskRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
 }
 

imm/src/model/CreateOfficeConversionTaskResult.cc

@@ -39,41 +39,20 @@ void CreateOfficeConversionTaskResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Status"].isNull())
-		status_ = value["Status"].asString();
 	if(!value["TaskId"].isNull())
 		taskId_ = value["TaskId"].asString();
-	if(!value["Percent"].isNull())
-		percent_ = std::stoi(value["Percent"].asString());
-	if(!value["CreateTime"].isNull())
-		createTime_ = value["CreateTime"].asString();
-	if(!value["TgtLoc"].isNull())
-		tgtLoc_ = value["TgtLoc"].asString();
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
 
 }
 
-std::string CreateOfficeConversionTaskResult::getStatus()const
-{
-	return status_;
-}
-
 std::string CreateOfficeConversionTaskResult::getTaskId()const
 {
 	return taskId_;
 }
 
-int CreateOfficeConversionTaskResult::getPercent()const
+std::string CreateOfficeConversionTaskResult::getEventId()const
 {
-	return percent_;
-}
-
-std::string CreateOfficeConversionTaskResult::getCreateTime()const
-{
-	return createTime_;
-}
-
-std::string CreateOfficeConversionTaskResult::getTgtLoc()const
-{
-	return tgtLoc_;
+	return eventId_;
 }
 

imm/src/model/CreateProjectRequest.cc

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateProjectRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateProjectRequest;
+
+CreateProjectRequest::CreateProjectRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateProject") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateProjectRequest::~CreateProjectRequest() {}
+
+long CreateProjectRequest::getEngineConcurrency() const {
+  return engineConcurrency_;
+}
+
+void CreateProjectRequest::setEngineConcurrency(long engineConcurrency) {
+  engineConcurrency_ = engineConcurrency;
+  setParameter(std::string("EngineConcurrency"), std::to_string(engineConcurrency));
+}
+
+long CreateProjectRequest::getDatasetMaxBindCount() const {
+  return datasetMaxBindCount_;
+}
+
+void CreateProjectRequest::setDatasetMaxBindCount(long datasetMaxBindCount) {
+  datasetMaxBindCount_ = datasetMaxBindCount;
+  setParameter(std::string("DatasetMaxBindCount"), std::to_string(datasetMaxBindCount));
+}
+
+std::string CreateProjectRequest::getDescription() const {
+  return description_;
+}
+
+void CreateProjectRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+long CreateProjectRequest::getProjectQueriesPerSecond() const {
+  return projectQueriesPerSecond_;
+}
+
+void CreateProjectRequest::setProjectQueriesPerSecond(long projectQueriesPerSecond) {
+  projectQueriesPerSecond_ = projectQueriesPerSecond;
+  setParameter(std::string("ProjectQueriesPerSecond"), std::to_string(projectQueriesPerSecond));
+}
+
+long CreateProjectRequest::getDatasetMaxRelationCount() const {
+  return datasetMaxRelationCount_;
+}
+
+void CreateProjectRequest::setDatasetMaxRelationCount(long datasetMaxRelationCount) {
+  datasetMaxRelationCount_ = datasetMaxRelationCount;
+  setParameter(std::string("DatasetMaxRelationCount"), std::to_string(datasetMaxRelationCount));
+}
+
+long CreateProjectRequest::getDatasetMaxFileCount() const {
+  return datasetMaxFileCount_;
+}
+
+void CreateProjectRequest::setDatasetMaxFileCount(long datasetMaxFileCount) {
+  datasetMaxFileCount_ = datasetMaxFileCount;
+  setParameter(std::string("DatasetMaxFileCount"), std::to_string(datasetMaxFileCount));
+}
+
+std::string CreateProjectRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateProjectRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+long CreateProjectRequest::getProjectMaxDatasetCount() const {
+  return projectMaxDatasetCount_;
+}
+
+void CreateProjectRequest::setProjectMaxDatasetCount(long projectMaxDatasetCount) {
+  projectMaxDatasetCount_ = projectMaxDatasetCount;
+  setParameter(std::string("ProjectMaxDatasetCount"), std::to_string(projectMaxDatasetCount));
+}
+
+long CreateProjectRequest::getDatasetMaxEntityCount() const {
+  return datasetMaxEntityCount_;
+}
+
+void CreateProjectRequest::setDatasetMaxEntityCount(long datasetMaxEntityCount) {
+  datasetMaxEntityCount_ = datasetMaxEntityCount;
+  setParameter(std::string("DatasetMaxEntityCount"), std::to_string(datasetMaxEntityCount));
+}
+
+std::string CreateProjectRequest::getTemplateId() const {
+  return templateId_;
+}
+
+void CreateProjectRequest::setTemplateId(const std::string &templateId) {
+  templateId_ = templateId;
+  setParameter(std::string("TemplateId"), templateId);
+}
+
+long CreateProjectRequest::getDatasetMaxTotalFileSize() const {
+  return datasetMaxTotalFileSize_;
+}
+
+void CreateProjectRequest::setDatasetMaxTotalFileSize(long datasetMaxTotalFileSize) {
+  datasetMaxTotalFileSize_ = datasetMaxTotalFileSize;
+  setParameter(std::string("DatasetMaxTotalFileSize"), std::to_string(datasetMaxTotalFileSize));
+}
+
+std::string CreateProjectRequest::getServiceRole() const {
+  return serviceRole_;
+}
+
+void CreateProjectRequest::setServiceRole(const std::string &serviceRole) {
+  serviceRole_ = serviceRole;
+  setParameter(std::string("ServiceRole"), serviceRole);
+}
+

imm/src/model/CreateProjectResult.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/imm/model/CreateProjectResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateProjectResult::CreateProjectResult() :
+	ServiceResult()
+{}
+
+CreateProjectResult::CreateProjectResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateProjectResult::~CreateProjectResult()
+{}
+
+void CreateProjectResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto projectNode = value["Project"];
+	if(!projectNode["ProjectName"].isNull())
+		project_.projectName = projectNode["ProjectName"].asString();
+	if(!projectNode["ServiceRole"].isNull())
+		project_.serviceRole = projectNode["ServiceRole"].asString();
+	if(!projectNode["TemplateId"].isNull())
+		project_.templateId = projectNode["TemplateId"].asString();
+	if(!projectNode["CreateTime"].isNull())
+		project_.createTime = projectNode["CreateTime"].asString();
+	if(!projectNode["UpdateTime"].isNull())
+		project_.updateTime = projectNode["UpdateTime"].asString();
+	if(!projectNode["Description"].isNull())
+		project_.description = projectNode["Description"].asString();
+	if(!projectNode["ProjectQueriesPerSecond"].isNull())
+		project_.projectQueriesPerSecond = std::stol(projectNode["ProjectQueriesPerSecond"].asString());
+	if(!projectNode["EngineConcurrency"].isNull())
+		project_.engineConcurrency = std::stol(projectNode["EngineConcurrency"].asString());
+	if(!projectNode["ProjectMaxDatasetCount"].isNull())
+		project_.projectMaxDatasetCount = std::stol(projectNode["ProjectMaxDatasetCount"].asString());
+	if(!projectNode["DatasetMaxBindCount"].isNull())
+		project_.datasetMaxBindCount = std::stol(projectNode["DatasetMaxBindCount"].asString());
+	if(!projectNode["DatasetMaxFileCount"].isNull())
+		project_.datasetMaxFileCount = std::stol(projectNode["DatasetMaxFileCount"].asString());
+	if(!projectNode["DatasetMaxEntityCount"].isNull())
+		project_.datasetMaxEntityCount = std::stol(projectNode["DatasetMaxEntityCount"].asString());
+	if(!projectNode["DatasetMaxRelationCount"].isNull())
+		project_.datasetMaxRelationCount = std::stol(projectNode["DatasetMaxRelationCount"].asString());
+	if(!projectNode["DatasetMaxTotalFileSize"].isNull())
+		project_.datasetMaxTotalFileSize = std::stol(projectNode["DatasetMaxTotalFileSize"].asString());
+	if(!projectNode["DatasetCount"].isNull())
+		project_.datasetCount = std::stol(projectNode["DatasetCount"].asString());
+	if(!projectNode["FileCount"].isNull())
+		project_.fileCount = std::stol(projectNode["FileCount"].asString());
+	if(!projectNode["TotalFileSize"].isNull())
+		project_.totalFileSize = std::stol(projectNode["TotalFileSize"].asString());
+
+}
+
+CreateProjectResult::Project CreateProjectResult::getProject()const
+{
+	return project_;
+}
+

imm/src/model/CreateSetRequest.cc

@@ -1,63 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateSetRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateSetRequest;
-
-CreateSetRequest::CreateSetRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateSet") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateSetRequest::~CreateSetRequest() {}
-
-std::string CreateSetRequest::getProject() const {
-  return project_;
-}
-
-void CreateSetRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateSetRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateSetRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateSetRequest::getSetName() const {
-  return setName_;
-}
-
-void CreateSetRequest::setSetName(const std::string &setName) {
-  setName_ = setName;
-  setParameter(std::string("SetName"), setName);
-}
-
-std::string CreateSetRequest::getSetId() const {
-  return setId_;
-}
-
-void CreateSetRequest::setSetId(const std::string &setId) {
-  setId_ = setId;
-  setParameter(std::string("SetId"), setId);
-}
-

imm/src/model/CreateSetResult.cc

@@ -1,100 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateSetResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-CreateSetResult::CreateSetResult() :
-	ServiceResult()
-{}
-
-CreateSetResult::CreateSetResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-CreateSetResult::~CreateSetResult()
-{}
-
-void CreateSetResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	if(!value["ModifyTime"].isNull())
-		modifyTime_ = value["ModifyTime"].asString();
-	if(!value["VideoCount"].isNull())
-		videoCount_ = std::stoi(value["VideoCount"].asString());
-	if(!value["ImageCount"].isNull())
-		imageCount_ = std::stoi(value["ImageCount"].asString());
-	if(!value["CreateTime"].isNull())
-		createTime_ = value["CreateTime"].asString();
-	if(!value["SetName"].isNull())
-		setName_ = value["SetName"].asString();
-	if(!value["SetId"].isNull())
-		setId_ = value["SetId"].asString();
-	if(!value["VideoLength"].isNull())
-		videoLength_ = std::stoi(value["VideoLength"].asString());
-	if(!value["FaceCount"].isNull())
-		faceCount_ = std::stoi(value["FaceCount"].asString());
-
-}
-
-std::string CreateSetResult::getModifyTime()const
-{
-	return modifyTime_;
-}
-
-int CreateSetResult::getVideoCount()const
-{
-	return videoCount_;
-}
-
-int CreateSetResult::getImageCount()const
-{
-	return imageCount_;
-}
-
-std::string CreateSetResult::getCreateTime()const
-{
-	return createTime_;
-}
-
-std::string CreateSetResult::getSetName()const
-{
-	return setName_;
-}
-
-std::string CreateSetResult::getSetId()const
-{
-	return setId_;
-}
-
-int CreateSetResult::getVideoLength()const
-{
-	return videoLength_;
-}
-
-int CreateSetResult::getFaceCount()const
-{
-	return faceCount_;
-}
-

imm/src/model/CreateStoryRequest.cc

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateStoryRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateStoryRequest;
+
+CreateStoryRequest::CreateStoryRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateStory") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateStoryRequest::~CreateStoryRequest() {}
+
+std::string CreateStoryRequest::getCustomLabels() const {
+  return customLabels_;
+}
+
+void CreateStoryRequest::setCustomLabels(const std::string &customLabels) {
+  customLabels_ = customLabels;
+  setBodyParameter(std::string("CustomLabels"), customLabels);
+}
+
+std::string CreateStoryRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateStoryRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setBodyParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateStoryRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateStoryRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setBodyParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateStoryRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateStoryRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setBodyParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+std::string CreateStoryRequest::getStoryType() const {
+  return storyType_;
+}
+
+void CreateStoryRequest::setStoryType(const std::string &storyType) {
+  storyType_ = storyType;
+  setBodyParameter(std::string("StoryType"), storyType);
+}
+
+std::map<std::string, std::string> CreateStoryRequest::getTags() const {
+  return tags_;
+}
+
+void CreateStoryRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+
+std::string CreateStoryRequest::getStorySubType() const {
+  return storySubType_;
+}
+
+void CreateStoryRequest::setStorySubType(const std::string &storySubType) {
+  storySubType_ = storySubType;
+  setBodyParameter(std::string("StorySubType"), storySubType);
+}
+
+long CreateStoryRequest::getMinFileCount() const {
+  return minFileCount_;
+}
+
+void CreateStoryRequest::setMinFileCount(long minFileCount) {
+  minFileCount_ = minFileCount;
+  setBodyParameter(std::string("MinFileCount"), std::to_string(minFileCount));
+}
+
+std::string CreateStoryRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateStoryRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+long CreateStoryRequest::getMaxFileCount() const {
+  return maxFileCount_;
+}
+
+void CreateStoryRequest::setMaxFileCount(long maxFileCount) {
+  maxFileCount_ = maxFileCount;
+  setBodyParameter(std::string("MaxFileCount"), std::to_string(maxFileCount));
+}
+
+std::string CreateStoryRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void CreateStoryRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setBodyParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string CreateStoryRequest::getStoryStartTime() const {
+  return storyStartTime_;
+}
+
+void CreateStoryRequest::setStoryStartTime(const std::string &storyStartTime) {
+  storyStartTime_ = storyStartTime;
+  setBodyParameter(std::string("StoryStartTime"), storyStartTime);
+}
+
+std::string CreateStoryRequest::getCustomId() const {
+  return customId_;
+}
+
+void CreateStoryRequest::setCustomId(const std::string &customId) {
+  customId_ = customId;
+  setBodyParameter(std::string("CustomId"), customId);
+}
+
+std::string CreateStoryRequest::getStoryEndTime() const {
+  return storyEndTime_;
+}
+
+void CreateStoryRequest::setStoryEndTime(const std::string &storyEndTime) {
+  storyEndTime_ = storyEndTime;
+  setBodyParameter(std::string("StoryEndTime"), storyEndTime);
+}
+
+std::string CreateStoryRequest::getObjectId() const {
+  return objectId_;
+}
+
+void CreateStoryRequest::setObjectId(const std::string &objectId) {
+  objectId_ = objectId;
+  setBodyParameter(std::string("ObjectId"), objectId);
+}
+
+std::string CreateStoryRequest::getStoryName() const {
+  return storyName_;
+}
+
+void CreateStoryRequest::setStoryName(const std::string &storyName) {
+  storyName_ = storyName;
+  setBodyParameter(std::string("StoryName"), storyName);
+}
+

imm/src/model/CreateStoryResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateGrabFrameTaskResult.h>
+#include <alibabacloud/imm/model/CreateStoryResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateGrabFrameTaskResult::CreateGrabFrameTaskResult() :
+CreateStoryResult::CreateStoryResult() :
 	ServiceResult()
 {}
 
-CreateGrabFrameTaskResult::CreateGrabFrameTaskResult(const std::string &payload) :
+CreateStoryResult::CreateStoryResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateGrabFrameTaskResult::~CreateGrabFrameTaskResult()
+CreateStoryResult::~CreateStoryResult()
 {}
 
-void CreateGrabFrameTaskResult::parse(const std::string &payload)
+void CreateStoryResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
@@ -41,18 +41,18 @@ void CreateGrabFrameTaskResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	if(!value["TaskId"].isNull())
 		taskId_ = value["TaskId"].asString();
-	if(!value["TaskType"].isNull())
-		taskType_ = value["TaskType"].asString();
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
 
 }
 
-std::string CreateGrabFrameTaskResult::getTaskId()const
+std::string CreateStoryResult::getTaskId()const
 {
 	return taskId_;
 }
 
-std::string CreateGrabFrameTaskResult::getTaskType()const
+std::string CreateStoryResult::getEventId()const
 {
-	return taskType_;
+	return eventId_;
 }
 

imm/src/model/CreateVideoAbstractTaskRequest.cc

@@ -1,99 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateVideoAbstractTaskRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateVideoAbstractTaskRequest;
-
-CreateVideoAbstractTaskRequest::CreateVideoAbstractTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateVideoAbstractTask") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateVideoAbstractTaskRequest::~CreateVideoAbstractTaskRequest() {}
-
-std::string CreateVideoAbstractTaskRequest::getTargetVideoUri() const {
-  return targetVideoUri_;
-}
-
-void CreateVideoAbstractTaskRequest::setTargetVideoUri(const std::string &targetVideoUri) {
-  targetVideoUri_ = targetVideoUri;
-  setParameter(std::string("TargetVideoUri"), targetVideoUri);
-}
-
-std::string CreateVideoAbstractTaskRequest::getProject() const {
-  return project_;
-}
-
-void CreateVideoAbstractTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateVideoAbstractTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateVideoAbstractTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateVideoAbstractTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateVideoAbstractTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-std::string CreateVideoAbstractTaskRequest::getNotifyTopicName() const {
-  return notifyTopicName_;
-}
-
-void CreateVideoAbstractTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
-  notifyTopicName_ = notifyTopicName;
-  setParameter(std::string("NotifyTopicName"), notifyTopicName);
-}
-
-std::string CreateVideoAbstractTaskRequest::getVideoUri() const {
-  return videoUri_;
-}
-
-void CreateVideoAbstractTaskRequest::setVideoUri(const std::string &videoUri) {
-  videoUri_ = videoUri;
-  setParameter(std::string("VideoUri"), videoUri);
-}
-
-int CreateVideoAbstractTaskRequest::getAbstractLength() const {
-  return abstractLength_;
-}
-
-void CreateVideoAbstractTaskRequest::setAbstractLength(int abstractLength) {
-  abstractLength_ = abstractLength;
-  setParameter(std::string("AbstractLength"), std::to_string(abstractLength));
-}
-
-std::string CreateVideoAbstractTaskRequest::getTargetClipsUri() const {
-  return targetClipsUri_;
-}
-
-void CreateVideoAbstractTaskRequest::setTargetClipsUri(const std::string &targetClipsUri) {
-  targetClipsUri_ = targetClipsUri;
-  setParameter(std::string("TargetClipsUri"), targetClipsUri);
-}
-

imm/src/model/CreateVideoAnalyseTaskRequest.cc

@@ -1,126 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateVideoAnalyseTaskRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateVideoAnalyseTaskRequest;
-
-CreateVideoAnalyseTaskRequest::CreateVideoAnalyseTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateVideoAnalyseTask") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateVideoAnalyseTaskRequest::~CreateVideoAnalyseTaskRequest() {}
-
-std::string CreateVideoAnalyseTaskRequest::getGrabType() const {
-  return grabType_;
-}
-
-void CreateVideoAnalyseTaskRequest::setGrabType(const std::string &grabType) {
-  grabType_ = grabType;
-  setParameter(std::string("GrabType"), grabType);
-}
-
-std::string CreateVideoAnalyseTaskRequest::getProject() const {
-  return project_;
-}
-
-void CreateVideoAnalyseTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateVideoAnalyseTaskRequest::getStartTime() const {
-  return startTime_;
-}
-
-void CreateVideoAnalyseTaskRequest::setStartTime(const std::string &startTime) {
-  startTime_ = startTime;
-  setParameter(std::string("StartTime"), startTime);
-}
-
-std::string CreateVideoAnalyseTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateVideoAnalyseTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateVideoAnalyseTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateVideoAnalyseTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-std::string CreateVideoAnalyseTaskRequest::getNotifyTopicName() const {
-  return notifyTopicName_;
-}
-
-void CreateVideoAnalyseTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
-  notifyTopicName_ = notifyTopicName;
-  setParameter(std::string("NotifyTopicName"), notifyTopicName);
-}
-
-std::string CreateVideoAnalyseTaskRequest::getEndTime() const {
-  return endTime_;
-}
-
-void CreateVideoAnalyseTaskRequest::setEndTime(const std::string &endTime) {
-  endTime_ = endTime;
-  setParameter(std::string("EndTime"), endTime);
-}
-
-std::string CreateVideoAnalyseTaskRequest::getVideoUri() const {
-  return videoUri_;
-}
-
-void CreateVideoAnalyseTaskRequest::setVideoUri(const std::string &videoUri) {
-  videoUri_ = videoUri;
-  setParameter(std::string("VideoUri"), videoUri);
-}
-
-bool CreateVideoAnalyseTaskRequest::getSaveType() const {
-  return saveType_;
-}
-
-void CreateVideoAnalyseTaskRequest::setSaveType(bool saveType) {
-  saveType_ = saveType;
-  setParameter(std::string("SaveType"), saveType ? "true" : "false");
-}
-
-std::string CreateVideoAnalyseTaskRequest::getInterval() const {
-  return interval_;
-}
-
-void CreateVideoAnalyseTaskRequest::setInterval(const std::string &interval) {
-  interval_ = interval;
-  setParameter(std::string("Interval"), interval);
-}
-
-std::string CreateVideoAnalyseTaskRequest::getTgtUri() const {
-  return tgtUri_;
-}
-
-void CreateVideoAnalyseTaskRequest::setTgtUri(const std::string &tgtUri) {
-  tgtUri_ = tgtUri;
-  setParameter(std::string("TgtUri"), tgtUri);
-}
-

imm/src/model/CreateVideoCompressTaskRequest.cc

@@ -1,117 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateVideoCompressTaskRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateVideoCompressTaskRequest;
-
-CreateVideoCompressTaskRequest::CreateVideoCompressTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateVideoCompressTask") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateVideoCompressTaskRequest::~CreateVideoCompressTaskRequest() {}
-
-std::string CreateVideoCompressTaskRequest::getTargetSubtitle() const {
-  return targetSubtitle_;
-}
-
-void CreateVideoCompressTaskRequest::setTargetSubtitle(const std::string &targetSubtitle) {
-  targetSubtitle_ = targetSubtitle;
-  setParameter(std::string("TargetSubtitle"), targetSubtitle);
-}
-
-std::string CreateVideoCompressTaskRequest::getProject() const {
-  return project_;
-}
-
-void CreateVideoCompressTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateVideoCompressTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateVideoCompressTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateVideoCompressTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateVideoCompressTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-std::string CreateVideoCompressTaskRequest::getTargetContainer() const {
-  return targetContainer_;
-}
-
-void CreateVideoCompressTaskRequest::setTargetContainer(const std::string &targetContainer) {
-  targetContainer_ = targetContainer;
-  setParameter(std::string("TargetContainer"), targetContainer);
-}
-
-std::string CreateVideoCompressTaskRequest::getCustomMessage() const {
-  return customMessage_;
-}
-
-void CreateVideoCompressTaskRequest::setCustomMessage(const std::string &customMessage) {
-  customMessage_ = customMessage;
-  setParameter(std::string("CustomMessage"), customMessage);
-}
-
-std::string CreateVideoCompressTaskRequest::getNotifyTopicName() const {
-  return notifyTopicName_;
-}
-
-void CreateVideoCompressTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
-  notifyTopicName_ = notifyTopicName;
-  setParameter(std::string("NotifyTopicName"), notifyTopicName);
-}
-
-std::string CreateVideoCompressTaskRequest::getTargetList() const {
-  return targetList_;
-}
-
-void CreateVideoCompressTaskRequest::setTargetList(const std::string &targetList) {
-  targetList_ = targetList;
-  setParameter(std::string("TargetList"), targetList);
-}
-
-std::string CreateVideoCompressTaskRequest::getVideoUri() const {
-  return videoUri_;
-}
-
-void CreateVideoCompressTaskRequest::setVideoUri(const std::string &videoUri) {
-  videoUri_ = videoUri;
-  setParameter(std::string("VideoUri"), videoUri);
-}
-
-std::string CreateVideoCompressTaskRequest::getTargetSegment() const {
-  return targetSegment_;
-}
-
-void CreateVideoCompressTaskRequest::setTargetSegment(const std::string &targetSegment) {
-  targetSegment_ = targetSegment;
-  setParameter(std::string("TargetSegment"), targetSegment);
-}
-

imm/src/model/CreateVideoModerationTaskRequest.cc

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/CreateVideoModerationTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateVideoModerationTaskRequest;
+
+CreateVideoModerationTaskRequest::CreateVideoModerationTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateVideoModerationTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateVideoModerationTaskRequest::~CreateVideoModerationTaskRequest() {}
+
+std::string CreateVideoModerationTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateVideoModerationTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+std::string CreateVideoModerationTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateVideoModerationTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateVideoModerationTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateVideoModerationTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateVideoModerationTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateVideoModerationTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+long CreateVideoModerationTaskRequest::getMaxFrames() const {
+  return maxFrames_;
+}
+
+void CreateVideoModerationTaskRequest::setMaxFrames(long maxFrames) {
+  maxFrames_ = maxFrames;
+  setParameter(std::string("MaxFrames"), std::to_string(maxFrames));
+}
+
+CreateVideoModerationTaskRequest::CredentialConfig CreateVideoModerationTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateVideoModerationTaskRequest::setCredentialConfig(const CreateVideoModerationTaskRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
+}
+
+std::string CreateVideoModerationTaskRequest::getReviewer() const {
+  return reviewer_;
+}
+
+void CreateVideoModerationTaskRequest::setReviewer(const std::string &reviewer) {
+  reviewer_ = reviewer;
+  setParameter(std::string("Reviewer"), reviewer);
+}
+
+std::map<std::string, std::string> CreateVideoModerationTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateVideoModerationTaskRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+
+std::string CreateVideoModerationTaskRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void CreateVideoModerationTaskRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+
+std::vector<CreateVideoModerationTaskRequest::std::string> CreateVideoModerationTaskRequest::getScenes() const {
+  return scenes_;
+}
+
+void CreateVideoModerationTaskRequest::setScenes(const std::vector<CreateVideoModerationTaskRequest::std::string> &scenes) {
+  scenes_ = scenes;
+  for(int dep1 = 0; dep1 != scenes.size(); dep1++) {
+    setParameter(std::string("Scenes") + "." + std::to_string(dep1 + 1), scenes[dep1]);
+  }
+}
+
+long CreateVideoModerationTaskRequest::getInterval() const {
+  return interval_;
+}
+
+void CreateVideoModerationTaskRequest::setInterval(long interval) {
+  interval_ = interval;
+  setParameter(std::string("Interval"), std::to_string(interval));
+}
+

imm/src/model/CreateVideoModerationTaskResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateVideoAbstractTaskResult.h>
+#include <alibabacloud/imm/model/CreateVideoModerationTaskResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateVideoAbstractTaskResult::CreateVideoAbstractTaskResult() :
+CreateVideoModerationTaskResult::CreateVideoModerationTaskResult() :
 	ServiceResult()
 {}
 
-CreateVideoAbstractTaskResult::CreateVideoAbstractTaskResult(const std::string &payload) :
+CreateVideoModerationTaskResult::CreateVideoModerationTaskResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateVideoAbstractTaskResult::~CreateVideoAbstractTaskResult()
+CreateVideoModerationTaskResult::~CreateVideoModerationTaskResult()
 {}
 
-void CreateVideoAbstractTaskResult::parse(const std::string &payload)
+void CreateVideoModerationTaskResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
@@ -41,18 +41,18 @@ void CreateVideoAbstractTaskResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	if(!value["TaskId"].isNull())
 		taskId_ = value["TaskId"].asString();
-	if(!value["TaskType"].isNull())
-		taskType_ = value["TaskType"].asString();
+	if(!value["EventId"].isNull())
+		eventId_ = value["EventId"].asString();
 
 }
 
-std::string CreateVideoAbstractTaskResult::getTaskId()const
+std::string CreateVideoModerationTaskResult::getTaskId()const
 {
 	return taskId_;
 }
 
-std::string CreateVideoAbstractTaskResult::getTaskType()const
+std::string CreateVideoModerationTaskResult::getEventId()const
 {
-	return taskType_;
+	return eventId_;
 }
 

imm/src/model/CreateVideoProduceTaskRequest.cc

@@ -1,126 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateVideoProduceTaskRequest.h>
-
-using AlibabaCloud::Imm::Model::CreateVideoProduceTaskRequest;
-
-CreateVideoProduceTaskRequest::CreateVideoProduceTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CreateVideoProduceTask") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateVideoProduceTaskRequest::~CreateVideoProduceTaskRequest() {}
-
-std::string CreateVideoProduceTaskRequest::getProject() const {
-  return project_;
-}
-
-void CreateVideoProduceTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string CreateVideoProduceTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void CreateVideoProduceTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string CreateVideoProduceTaskRequest::getMusic() const {
-  return music_;
-}
-
-void CreateVideoProduceTaskRequest::setMusic(const std::string &music) {
-  music_ = music;
-  setParameter(std::string("Music"), music);
-}
-
-std::string CreateVideoProduceTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateVideoProduceTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-std::string CreateVideoProduceTaskRequest::getTargetUri() const {
-  return targetUri_;
-}
-
-void CreateVideoProduceTaskRequest::setTargetUri(const std::string &targetUri) {
-  targetUri_ = targetUri;
-  setParameter(std::string("TargetUri"), targetUri);
-}
-
-std::string CreateVideoProduceTaskRequest::getTemplateName() const {
-  return templateName_;
-}
-
-void CreateVideoProduceTaskRequest::setTemplateName(const std::string &templateName) {
-  templateName_ = templateName;
-  setParameter(std::string("TemplateName"), templateName);
-}
-
-int CreateVideoProduceTaskRequest::getHeight() const {
-  return height_;
-}
-
-void CreateVideoProduceTaskRequest::setHeight(int height) {
-  height_ = height;
-  setParameter(std::string("Height"), std::to_string(height));
-}
-
-std::string CreateVideoProduceTaskRequest::getCustomMessage() const {
-  return customMessage_;
-}
-
-void CreateVideoProduceTaskRequest::setCustomMessage(const std::string &customMessage) {
-  customMessage_ = customMessage;
-  setParameter(std::string("CustomMessage"), customMessage);
-}
-
-std::string CreateVideoProduceTaskRequest::getImages() const {
-  return images_;
-}
-
-void CreateVideoProduceTaskRequest::setImages(const std::string &images) {
-  images_ = images;
-  setParameter(std::string("Images"), images);
-}
-
-std::string CreateVideoProduceTaskRequest::getNotifyTopicName() const {
-  return notifyTopicName_;
-}
-
-void CreateVideoProduceTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
-  notifyTopicName_ = notifyTopicName;
-  setParameter(std::string("NotifyTopicName"), notifyTopicName);
-}
-
-int CreateVideoProduceTaskRequest::getWidth() const {
-  return width_;
-}
-
-void CreateVideoProduceTaskRequest::setWidth(int width) {
-  width_ = width;
-  setParameter(std::string("Width"), std::to_string(width));
-}
-

imm/src/model/CreateVideoProduceTaskResult.cc

@@ -1,58 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/CreateVideoProduceTaskResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-CreateVideoProduceTaskResult::CreateVideoProduceTaskResult() :
-	ServiceResult()
-{}
-
-CreateVideoProduceTaskResult::CreateVideoProduceTaskResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-CreateVideoProduceTaskResult::~CreateVideoProduceTaskResult()
-{}
-
-void CreateVideoProduceTaskResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	if(!value["TaskId"].isNull())
-		taskId_ = value["TaskId"].asString();
-	if(!value["TaskType"].isNull())
-		taskType_ = value["TaskType"].asString();
-
-}
-
-std::string CreateVideoProduceTaskResult::getTaskId()const
-{
-	return taskId_;
-}
-
-std::string CreateVideoProduceTaskResult::getTaskType()const
-{
-	return taskType_;
-}
-

imm/src/model/DecodeBlindWatermarkRequest.cc

@@ -1,99 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DecodeBlindWatermarkRequest.h>
-
-using AlibabaCloud::Imm::Model::DecodeBlindWatermarkRequest;
-
-DecodeBlindWatermarkRequest::DecodeBlindWatermarkRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DecodeBlindWatermark") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DecodeBlindWatermarkRequest::~DecodeBlindWatermarkRequest() {}
-
-int DecodeBlindWatermarkRequest::getImageQuality() const {
-  return imageQuality_;
-}
-
-void DecodeBlindWatermarkRequest::setImageQuality(int imageQuality) {
-  imageQuality_ = imageQuality;
-  setParameter(std::string("ImageQuality"), std::to_string(imageQuality));
-}
-
-std::string DecodeBlindWatermarkRequest::getProject() const {
-  return project_;
-}
-
-void DecodeBlindWatermarkRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DecodeBlindWatermarkRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DecodeBlindWatermarkRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DecodeBlindWatermarkRequest::getWatermarkType() const {
-  return watermarkType_;
-}
-
-void DecodeBlindWatermarkRequest::setWatermarkType(const std::string &watermarkType) {
-  watermarkType_ = watermarkType;
-  setParameter(std::string("WatermarkType"), watermarkType);
-}
-
-std::string DecodeBlindWatermarkRequest::getTargetUri() const {
-  return targetUri_;
-}
-
-void DecodeBlindWatermarkRequest::setTargetUri(const std::string &targetUri) {
-  targetUri_ = targetUri;
-  setParameter(std::string("TargetUri"), targetUri);
-}
-
-std::string DecodeBlindWatermarkRequest::getModel() const {
-  return model_;
-}
-
-void DecodeBlindWatermarkRequest::setModel(const std::string &model) {
-  model_ = model;
-  setParameter(std::string("Model"), model);
-}
-
-std::string DecodeBlindWatermarkRequest::getImageUri() const {
-  return imageUri_;
-}
-
-void DecodeBlindWatermarkRequest::setImageUri(const std::string &imageUri) {
-  imageUri_ = imageUri;
-  setParameter(std::string("ImageUri"), imageUri);
-}
-
-std::string DecodeBlindWatermarkRequest::getOriginalImageUri() const {
-  return originalImageUri_;
-}
-
-void DecodeBlindWatermarkRequest::setOriginalImageUri(const std::string &originalImageUri) {
-  originalImageUri_ = originalImageUri;
-  setParameter(std::string("OriginalImageUri"), originalImageUri);
-}
-

imm/src/model/DecodeBlindWatermarkResult.cc

@@ -1,58 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DecodeBlindWatermarkResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-DecodeBlindWatermarkResult::DecodeBlindWatermarkResult() :
-	ServiceResult()
-{}
-
-DecodeBlindWatermarkResult::DecodeBlindWatermarkResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DecodeBlindWatermarkResult::~DecodeBlindWatermarkResult()
-{}
-
-void DecodeBlindWatermarkResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	if(!value["Content"].isNull())
-		content_ = value["Content"].asString();
-	if(!value["TargetUri"].isNull())
-		targetUri_ = value["TargetUri"].asString();
-
-}
-
-std::string DecodeBlindWatermarkResult::getContent()const
-{
-	return content_;
-}
-
-std::string DecodeBlindWatermarkResult::getTargetUri()const
-{
-	return targetUri_;
-}
-

imm/src/model/DeleteBindingRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/imm/model/DeleteBindingRequest.h>
+
+using AlibabaCloud::Imm::Model::DeleteBindingRequest;
+
+DeleteBindingRequest::DeleteBindingRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DeleteBinding") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteBindingRequest::~DeleteBindingRequest() {}
+
+std::string DeleteBindingRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void DeleteBindingRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string DeleteBindingRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DeleteBindingRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string DeleteBindingRequest::getURI() const {
+  return uRI_;
+}
+
+void DeleteBindingRequest::setURI(const std::string &uRI) {
+  uRI_ = uRI;
+  setParameter(std::string("URI"), uRI);
+}
+
+bool DeleteBindingRequest::getCleanup() const {
+  return cleanup_;
+}
+
+void DeleteBindingRequest::setCleanup(bool cleanup) {
+  cleanup_ = cleanup;
+  setParameter(std::string("Cleanup"), cleanup ? "true" : "false");
+}
+

imm/src/model/DeleteBindingResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/DeleteOfficeConversionTaskResult.h>
+#include <alibabacloud/imm/model/DeleteBindingResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-DeleteOfficeConversionTaskResult::DeleteOfficeConversionTaskResult() :
+DeleteBindingResult::DeleteBindingResult() :
 	ServiceResult()
 {}
 
-DeleteOfficeConversionTaskResult::DeleteOfficeConversionTaskResult(const std::string &payload) :
+DeleteBindingResult::DeleteBindingResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteOfficeConversionTaskResult::~DeleteOfficeConversionTaskResult()
+DeleteBindingResult::~DeleteBindingResult()
 {}
 
-void DeleteOfficeConversionTaskResult::parse(const std::string &payload)
+void DeleteBindingResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

imm/src/model/DeleteDatasetRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/DeleteDatasetRequest.h>
+
+using AlibabaCloud::Imm::Model::DeleteDatasetRequest;
+
+DeleteDatasetRequest::DeleteDatasetRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DeleteDataset") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDatasetRequest::~DeleteDatasetRequest() {}
+
+std::string DeleteDatasetRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void DeleteDatasetRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string DeleteDatasetRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DeleteDatasetRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+

imm/src/model/DeleteDatasetResult.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/imm/model/DeleteDatasetResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DeleteDatasetResult::DeleteDatasetResult() :
+	ServiceResult()
+{}
+
+DeleteDatasetResult::DeleteDatasetResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteDatasetResult::~DeleteDatasetResult()
+{}
+
+void DeleteDatasetResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

imm/src/model/DeleteFileMetaRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/imm/model/DeleteFileMetaRequest.h>
+
+using AlibabaCloud::Imm::Model::DeleteFileMetaRequest;
+
+DeleteFileMetaRequest::DeleteFileMetaRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DeleteFileMeta") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteFileMetaRequest::~DeleteFileMetaRequest() {}
+
+std::string DeleteFileMetaRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void DeleteFileMetaRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string DeleteFileMetaRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DeleteFileMetaRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string DeleteFileMetaRequest::getURI() const {
+  return uRI_;
+}
+
+void DeleteFileMetaRequest::setURI(const std::string &uRI) {
+  uRI_ = uRI;
+  setParameter(std::string("URI"), uRI);
+}
+

imm/src/model/DeleteFileMetaResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/DeleteImageJobResult.h>
+#include <alibabacloud/imm/model/DeleteFileMetaResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-DeleteImageJobResult::DeleteImageJobResult() :
+DeleteFileMetaResult::DeleteFileMetaResult() :
 	ServiceResult()
 {}
 
-DeleteImageJobResult::DeleteImageJobResult(const std::string &payload) :
+DeleteFileMetaResult::DeleteFileMetaResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteImageJobResult::~DeleteImageJobResult()
+DeleteFileMetaResult::~DeleteFileMetaResult()
 {}
 
-void DeleteImageJobResult::parse(const std::string &payload)
+void DeleteFileMetaResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

imm/src/model/DeleteImageJobRequest.cc

@@ -1,63 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DeleteImageJobRequest.h>
-
-using AlibabaCloud::Imm::Model::DeleteImageJobRequest;
-
-DeleteImageJobRequest::DeleteImageJobRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DeleteImageJob") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DeleteImageJobRequest::~DeleteImageJobRequest() {}
-
-std::string DeleteImageJobRequest::getProject() const {
-  return project_;
-}
-
-void DeleteImageJobRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DeleteImageJobRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DeleteImageJobRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DeleteImageJobRequest::getJobId() const {
-  return jobId_;
-}
-
-void DeleteImageJobRequest::setJobId(const std::string &jobId) {
-  jobId_ = jobId;
-  setParameter(std::string("JobId"), jobId);
-}
-
-std::string DeleteImageJobRequest::getJobType() const {
-  return jobType_;
-}
-
-void DeleteImageJobRequest::setJobType(const std::string &jobType) {
-  jobType_ = jobType;
-  setParameter(std::string("JobType"), jobType);
-}
-

imm/src/model/DeleteImageRequest.cc

@@ -1,63 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DeleteImageRequest.h>
-
-using AlibabaCloud::Imm::Model::DeleteImageRequest;
-
-DeleteImageRequest::DeleteImageRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DeleteImage") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DeleteImageRequest::~DeleteImageRequest() {}
-
-std::string DeleteImageRequest::getProject() const {
-  return project_;
-}
-
-void DeleteImageRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DeleteImageRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DeleteImageRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DeleteImageRequest::getImageUri() const {
-  return imageUri_;
-}
-
-void DeleteImageRequest::setImageUri(const std::string &imageUri) {
-  imageUri_ = imageUri;
-  setParameter(std::string("ImageUri"), imageUri);
-}
-
-std::string DeleteImageRequest::getSetId() const {
-  return setId_;
-}
-
-void DeleteImageRequest::setSetId(const std::string &setId) {
-  setId_ = setId;
-  setParameter(std::string("SetId"), setId);
-}
-

imm/src/model/DeleteOfficeConversionTaskRequest.cc

@@ -1,54 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DeleteOfficeConversionTaskRequest.h>
-
-using AlibabaCloud::Imm::Model::DeleteOfficeConversionTaskRequest;
-
-DeleteOfficeConversionTaskRequest::DeleteOfficeConversionTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DeleteOfficeConversionTask") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DeleteOfficeConversionTaskRequest::~DeleteOfficeConversionTaskRequest() {}
-
-std::string DeleteOfficeConversionTaskRequest::getProject() const {
-  return project_;
-}
-
-void DeleteOfficeConversionTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DeleteOfficeConversionTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DeleteOfficeConversionTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DeleteOfficeConversionTaskRequest::getTaskId() const {
-  return taskId_;
-}
-
-void DeleteOfficeConversionTaskRequest::setTaskId(const std::string &taskId) {
-  taskId_ = taskId;
-  setParameter(std::string("TaskId"), taskId);
-}
-

imm/src/model/DeleteProjectRequest.cc

@@ -19,27 +19,18 @@
 using AlibabaCloud::Imm::Model::DeleteProjectRequest;
 
 DeleteProjectRequest::DeleteProjectRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DeleteProject") {
+    : RpcServiceRequest("imm", "2020-09-30", "DeleteProject") {
   setMethod(HttpRequest::Method::Post);
 }
 
 DeleteProjectRequest::~DeleteProjectRequest() {}
 
-std::string DeleteProjectRequest::getProject() const {
-  return project_;
+std::string DeleteProjectRequest::getProjectName() const {
+  return projectName_;
 }
 
-void DeleteProjectRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DeleteProjectRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DeleteProjectRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void DeleteProjectRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
 }
 

imm/src/model/DeleteSetRequest.cc

@@ -1,54 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DeleteSetRequest.h>
-
-using AlibabaCloud::Imm::Model::DeleteSetRequest;
-
-DeleteSetRequest::DeleteSetRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DeleteSet") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DeleteSetRequest::~DeleteSetRequest() {}
-
-std::string DeleteSetRequest::getProject() const {
-  return project_;
-}
-
-void DeleteSetRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DeleteSetRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DeleteSetRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DeleteSetRequest::getSetId() const {
-  return setId_;
-}
-
-void DeleteSetRequest::setSetId(const std::string &setId) {
-  setId_ = setId;
-  setParameter(std::string("SetId"), setId);
-}
-

imm/src/model/DeleteStoryRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/imm/model/DeleteStoryRequest.h>
+
+using AlibabaCloud::Imm::Model::DeleteStoryRequest;
+
+DeleteStoryRequest::DeleteStoryRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DeleteStory") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteStoryRequest::~DeleteStoryRequest() {}
+
+std::string DeleteStoryRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void DeleteStoryRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string DeleteStoryRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DeleteStoryRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string DeleteStoryRequest::getObjectId() const {
+  return objectId_;
+}
+
+void DeleteStoryRequest::setObjectId(const std::string &objectId) {
+  objectId_ = objectId;
+  setParameter(std::string("ObjectId"), objectId);
+}
+

imm/src/model/DeleteStoryResult.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/imm/model/DeleteStoryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DeleteStoryResult::DeleteStoryResult() :
+	ServiceResult()
+{}
+
+DeleteStoryResult::DeleteStoryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteStoryResult::~DeleteStoryResult()
+{}
+
+void DeleteStoryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

imm/src/model/DeleteVideoRequest.cc

@@ -1,72 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DeleteVideoRequest.h>
-
-using AlibabaCloud::Imm::Model::DeleteVideoRequest;
-
-DeleteVideoRequest::DeleteVideoRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DeleteVideo") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DeleteVideoRequest::~DeleteVideoRequest() {}
-
-std::string DeleteVideoRequest::getProject() const {
-  return project_;
-}
-
-void DeleteVideoRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DeleteVideoRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DeleteVideoRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-bool DeleteVideoRequest::getResources() const {
-  return resources_;
-}
-
-void DeleteVideoRequest::setResources(bool resources) {
-  resources_ = resources;
-  setParameter(std::string("Resources"), resources ? "true" : "false");
-}
-
-std::string DeleteVideoRequest::getVideoUri() const {
-  return videoUri_;
-}
-
-void DeleteVideoRequest::setVideoUri(const std::string &videoUri) {
-  videoUri_ = videoUri;
-  setParameter(std::string("VideoUri"), videoUri);
-}
-
-std::string DeleteVideoRequest::getSetId() const {
-  return setId_;
-}
-
-void DeleteVideoRequest::setSetId(const std::string &setId) {
-  setId_ = setId;
-  setParameter(std::string("SetId"), setId);
-}
-

imm/src/model/DeleteVideoTaskRequest.cc

@@ -1,63 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DeleteVideoTaskRequest.h>
-
-using AlibabaCloud::Imm::Model::DeleteVideoTaskRequest;
-
-DeleteVideoTaskRequest::DeleteVideoTaskRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DeleteVideoTask") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DeleteVideoTaskRequest::~DeleteVideoTaskRequest() {}
-
-std::string DeleteVideoTaskRequest::getProject() const {
-  return project_;
-}
-
-void DeleteVideoTaskRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DeleteVideoTaskRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DeleteVideoTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DeleteVideoTaskRequest::getTaskId() const {
-  return taskId_;
-}
-
-void DeleteVideoTaskRequest::setTaskId(const std::string &taskId) {
-  taskId_ = taskId;
-  setParameter(std::string("TaskId"), taskId);
-}
-
-std::string DeleteVideoTaskRequest::getTaskType() const {
-  return taskType_;
-}
-
-void DeleteVideoTaskRequest::setTaskType(const std::string &taskType) {
-  taskType_ = taskType;
-  setParameter(std::string("TaskType"), taskType);
-}
-

imm/src/model/DescribeRegionsResult.cc

@@ -1,61 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DescribeRegionsResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-DescribeRegionsResult::DescribeRegionsResult() :
-	ServiceResult()
-{}
-
-DescribeRegionsResult::DescribeRegionsResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeRegionsResult::~DescribeRegionsResult()
-{}
-
-void DescribeRegionsResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto regionsNode = value["Regions"];
-	auto allRegionNode = regionsNode["Region"]["RegionItem"];
-	for (auto regionsNodeRegionRegionItem : allRegionNode)
-	{
-		Regions::RegionItem regionItemObject;
-		if(!regionsNodeRegionRegionItem["RegionId"].isNull())
-			regionItemObject.regionId = regionsNodeRegionRegionItem["RegionId"].asString();
-		auto allProjectTypes = value["ProjectTypes"]["ProjectTypes"];
-		for (auto value : allProjectTypes)
-			regionItemObject.projectTypes.push_back(value.asString());
-		regions_.region.push_back(regionItemObject);
-	}
-
-}
-
-DescribeRegionsResult::Regions DescribeRegionsResult::getRegions()const
-{
-	return regions_;
-}
-

imm/src/model/DetachOSSBucketRequest.cc

@@ -14,23 +14,23 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/OpenImmServiceRequest.h>
+#include <alibabacloud/imm/model/DetachOSSBucketRequest.h>
 
-using AlibabaCloud::Imm::Model::OpenImmServiceRequest;
+using AlibabaCloud::Imm::Model::DetachOSSBucketRequest;
 
-OpenImmServiceRequest::OpenImmServiceRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "OpenImmService") {
+DetachOSSBucketRequest::DetachOSSBucketRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DetachOSSBucket") {
   setMethod(HttpRequest::Method::Post);
 }
 
-OpenImmServiceRequest::~OpenImmServiceRequest() {}
+DetachOSSBucketRequest::~DetachOSSBucketRequest() {}
 
-long OpenImmServiceRequest::getOwnerId() const {
-  return ownerId_;
+std::string DetachOSSBucketRequest::getOSSBucket() const {
+  return oSSBucket_;
 }
 
-void OpenImmServiceRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+void DetachOSSBucketRequest::setOSSBucket(const std::string &oSSBucket) {
+  oSSBucket_ = oSSBucket;
+  setParameter(std::string("OSSBucket"), oSSBucket);
 }
 

imm/src/model/DetachOSSBucketResult.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/imm/model/DetachOSSBucketResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DetachOSSBucketResult::DetachOSSBucketResult() :
+	ServiceResult()
+{}
+
+DetachOSSBucketResult::DetachOSSBucketResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetachOSSBucketResult::~DetachOSSBucketResult()
+{}
+
+void DetachOSSBucketResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

imm/src/model/DetectImageBodiesRequest.cc

@@ -19,36 +19,51 @@
 using AlibabaCloud::Imm::Model::DetectImageBodiesRequest;
 
 DetectImageBodiesRequest::DetectImageBodiesRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DetectImageBodies") {
+    : RpcServiceRequest("imm", "2020-09-30", "DetectImageBodies") {
   setMethod(HttpRequest::Method::Post);
 }
 
 DetectImageBodiesRequest::~DetectImageBodiesRequest() {}
 
-std::string DetectImageBodiesRequest::getProject() const {
-  return project_;
+std::string DetectImageBodiesRequest::getProjectName() const {
+  return projectName_;
 }
 
-void DetectImageBodiesRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
+void DetectImageBodiesRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
 }
 
-std::string DetectImageBodiesRequest::getAccessKeyId() const {
-  return accessKeyId_;
+DetectImageBodiesRequest::CredentialConfig DetectImageBodiesRequest::getCredentialConfig() const {
+  return credentialConfig_;
 }
 
-void DetectImageBodiesRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void DetectImageBodiesRequest::setCredentialConfig(const DetectImageBodiesRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
 }
 
-std::string DetectImageBodiesRequest::getImageUri() const {
-  return imageUri_;
+std::string DetectImageBodiesRequest::getSourceURI() const {
+  return sourceURI_;
 }
 
-void DetectImageBodiesRequest::setImageUri(const std::string &imageUri) {
-  imageUri_ = imageUri;
-  setParameter(std::string("ImageUri"), imageUri);
+void DetectImageBodiesRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+
+float DetectImageBodiesRequest::getSensitivity() const {
+  return sensitivity_;
+}
+
+void DetectImageBodiesRequest::setSensitivity(float sensitivity) {
+  sensitivity_ = sensitivity;
+  setParameter(std::string("Sensitivity"), std::to_string(sensitivity));
 }
 

imm/src/model/DetectImageBodiesResult.cc

@@ -43,21 +43,19 @@ void DetectImageBodiesResult::parse(const std::string &payload)
 	for (auto valueBodiesBodiesItem : allBodiesNode)
 	{
 		BodiesItem bodiesObject;
-		if(!valueBodiesBodiesItem["BodyConfidence"].isNull())
-			bodiesObject.bodyConfidence = std::stof(valueBodiesBodiesItem["BodyConfidence"].asString());
-		auto bodyBoundaryNode = value["BodyBoundary"];
-		if(!bodyBoundaryNode["Top"].isNull())
-			bodiesObject.bodyBoundary.top = std::stoi(bodyBoundaryNode["Top"].asString());
-		if(!bodyBoundaryNode["Width"].isNull())
-			bodiesObject.bodyBoundary.width = std::stoi(bodyBoundaryNode["Width"].asString());
-		if(!bodyBoundaryNode["Height"].isNull())
-			bodiesObject.bodyBoundary.height = std::stoi(bodyBoundaryNode["Height"].asString());
-		if(!bodyBoundaryNode["Left"].isNull())
-			bodiesObject.bodyBoundary.left = std::stoi(bodyBoundaryNode["Left"].asString());
+		if(!valueBodiesBodiesItem["Confidence"].isNull())
+			bodiesObject.confidence = std::stof(valueBodiesBodiesItem["Confidence"].asString());
+		auto boundaryNode = value["Boundary"];
+		if(!boundaryNode["Width"].isNull())
+			bodiesObject.boundary.width = std::stol(boundaryNode["Width"].asString());
+		if(!boundaryNode["Height"].isNull())
+			bodiesObject.boundary.height = std::stol(boundaryNode["Height"].asString());
+		if(!boundaryNode["Left"].isNull())
+			bodiesObject.boundary.left = std::stol(boundaryNode["Left"].asString());
+		if(!boundaryNode["Top"].isNull())
+			bodiesObject.boundary.top = std::stol(boundaryNode["Top"].asString());
 		bodies_.push_back(bodiesObject);
 	}
-	if(!value["ImageUri"].isNull())
-		imageUri_ = value["ImageUri"].asString();
 
 }
 
@@ -66,8 +64,3 @@ std::vector<DetectImageBodiesResult::BodiesItem> DetectImageBodiesResult::getBod
 	return bodies_;
 }
 
-std::string DetectImageBodiesResult::getImageUri()const
-{
-	return imageUri_;
-}
-

imm/src/model/DetectImageCodesRequest.cc

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/DetectImageCodesRequest.h>
+
+using AlibabaCloud::Imm::Model::DetectImageCodesRequest;
+
+DetectImageCodesRequest::DetectImageCodesRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DetectImageCodes") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetectImageCodesRequest::~DetectImageCodesRequest() {}
+
+std::string DetectImageCodesRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DetectImageCodesRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+DetectImageCodesRequest::CredentialConfig DetectImageCodesRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void DetectImageCodesRequest::setCredentialConfig(const DetectImageCodesRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
+}
+
+std::string DetectImageCodesRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void DetectImageCodesRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/DetectImageCodesResult.cc

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/DetectImageCodesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DetectImageCodesResult::DetectImageCodesResult() :
+	ServiceResult()
+{}
+
+DetectImageCodesResult::DetectImageCodesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectImageCodesResult::~DetectImageCodesResult()
+{}
+
+void DetectImageCodesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCodesNode = value["Codes"]["CodesItem"];
+	for (auto valueCodesCodesItem : allCodesNode)
+	{
+		CodesItem codesObject;
+		if(!valueCodesCodesItem["Content"].isNull())
+			codesObject.content = valueCodesCodesItem["Content"].asString();
+		if(!valueCodesCodesItem["Confidence"].isNull())
+			codesObject.confidence = std::stof(valueCodesCodesItem["Confidence"].asString());
+		if(!valueCodesCodesItem["Type"].isNull())
+			codesObject.type = valueCodesCodesItem["Type"].asString();
+		auto boundaryNode = value["Boundary"];
+		if(!boundaryNode["Width"].isNull())
+			codesObject.boundary.width = std::stol(boundaryNode["Width"].asString());
+		if(!boundaryNode["Height"].isNull())
+			codesObject.boundary.height = std::stol(boundaryNode["Height"].asString());
+		if(!boundaryNode["Left"].isNull())
+			codesObject.boundary.left = std::stol(boundaryNode["Left"].asString());
+		if(!boundaryNode["Top"].isNull())
+			codesObject.boundary.top = std::stol(boundaryNode["Top"].asString());
+		codes_.push_back(codesObject);
+	}
+
+}
+
+std::vector<DetectImageCodesResult::CodesItem> DetectImageCodesResult::getCodes()const
+{
+	return codes_;
+}
+

imm/src/model/DetectImageCroppingRequest.cc

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/DetectImageCroppingRequest.h>
+
+using AlibabaCloud::Imm::Model::DetectImageCroppingRequest;
+
+DetectImageCroppingRequest::DetectImageCroppingRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DetectImageCropping") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetectImageCroppingRequest::~DetectImageCroppingRequest() {}
+
+std::string DetectImageCroppingRequest::getAspectRatios() const {
+  return aspectRatios_;
+}
+
+void DetectImageCroppingRequest::setAspectRatios(const std::string &aspectRatios) {
+  aspectRatios_ = aspectRatios;
+  setParameter(std::string("AspectRatios"), aspectRatios);
+}
+
+std::string DetectImageCroppingRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DetectImageCroppingRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+DetectImageCroppingRequest::CredentialConfig DetectImageCroppingRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void DetectImageCroppingRequest::setCredentialConfig(const DetectImageCroppingRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
+}
+
+std::string DetectImageCroppingRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void DetectImageCroppingRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/DetectImageCroppingResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/DetectImageCroppingResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DetectImageCroppingResult::DetectImageCroppingResult() :
+	ServiceResult()
+{}
+
+DetectImageCroppingResult::DetectImageCroppingResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectImageCroppingResult::~DetectImageCroppingResult()
+{}
+
+void DetectImageCroppingResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCroppingsNode = value["Croppings"]["CroppingsItem"];
+	for (auto valueCroppingsCroppingsItem : allCroppingsNode)
+	{
+		CroppingsItem croppingsObject;
+		if(!valueCroppingsCroppingsItem["AspectRatio"].isNull())
+			croppingsObject.aspectRatio = valueCroppingsCroppingsItem["AspectRatio"].asString();
+		if(!valueCroppingsCroppingsItem["Confidence"].isNull())
+			croppingsObject.confidence = std::stof(valueCroppingsCroppingsItem["Confidence"].asString());
+		auto boundaryNode = value["Boundary"];
+		if(!boundaryNode["Width"].isNull())
+			croppingsObject.boundary.width = std::stol(boundaryNode["Width"].asString());
+		if(!boundaryNode["Height"].isNull())
+			croppingsObject.boundary.height = std::stol(boundaryNode["Height"].asString());
+		if(!boundaryNode["Left"].isNull())
+			croppingsObject.boundary.left = std::stol(boundaryNode["Left"].asString());
+		if(!boundaryNode["Top"].isNull())
+			croppingsObject.boundary.top = std::stol(boundaryNode["Top"].asString());
+		croppings_.push_back(croppingsObject);
+	}
+
+}
+
+std::vector<DetectImageCroppingResult::CroppingsItem> DetectImageCroppingResult::getCroppings()const
+{
+	return croppings_;
+}
+

imm/src/model/DetectImageFacesRequest.cc

@@ -19,45 +19,42 @@
 using AlibabaCloud::Imm::Model::DetectImageFacesRequest;
 
 DetectImageFacesRequest::DetectImageFacesRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DetectImageFaces") {
+    : RpcServiceRequest("imm", "2020-09-30", "DetectImageFaces") {
   setMethod(HttpRequest::Method::Post);
 }
 
 DetectImageFacesRequest::~DetectImageFacesRequest() {}
 
-std::string DetectImageFacesRequest::getProject() const {
-  return project_;
+std::string DetectImageFacesRequest::getProjectName() const {
+  return projectName_;
 }
 
-void DetectImageFacesRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
+void DetectImageFacesRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
 }
 
-std::string DetectImageFacesRequest::getAccessKeyId() const {
-  return accessKeyId_;
+DetectImageFacesRequest::CredentialConfig DetectImageFacesRequest::getCredentialConfig() const {
+  return credentialConfig_;
 }
 
-void DetectImageFacesRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
+void DetectImageFacesRequest::setCredentialConfig(const DetectImageFacesRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
 }
 
-std::string DetectImageFacesRequest::getRealUid() const {
-  return realUid_;
+std::string DetectImageFacesRequest::getSourceURI() const {
+  return sourceURI_;
 }
 
-void DetectImageFacesRequest::setRealUid(const std::string &realUid) {
-  realUid_ = realUid;
-  setParameter(std::string("RealUid"), realUid);
-}
-
-std::string DetectImageFacesRequest::getImageUri() const {
-  return imageUri_;
-}
-
-void DetectImageFacesRequest::setImageUri(const std::string &imageUri) {
-  imageUri_ = imageUri;
-  setParameter(std::string("ImageUri"), imageUri);
+void DetectImageFacesRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
 }
 

imm/src/model/DetectImageFacesResult.cc

@@ -43,84 +43,75 @@ void DetectImageFacesResult::parse(const std::string &payload)
 	for (auto valueFacesFacesItem : allFacesNode)
 	{
 		FacesItem facesObject;
-		if(!valueFacesFacesItem["AttractiveConfidence"].isNull())
-			facesObject.attractiveConfidence = std::stof(valueFacesFacesItem["AttractiveConfidence"].asString());
+		if(!valueFacesFacesItem["FigureId"].isNull())
+			facesObject.figureId = valueFacesFacesItem["FigureId"].asString();
+		if(!valueFacesFacesItem["FigureConfidence"].isNull())
+			facesObject.figureConfidence = std::stof(valueFacesFacesItem["FigureConfidence"].asString());
+		if(!valueFacesFacesItem["FigureClusterId"].isNull())
+			facesObject.figureClusterId = valueFacesFacesItem["FigureClusterId"].asString();
+		if(!valueFacesFacesItem["FigureClusterConfidence"].isNull())
+			facesObject.figureClusterConfidence = std::stof(valueFacesFacesItem["FigureClusterConfidence"].asString());
+		if(!valueFacesFacesItem["FigureType"].isNull())
+			facesObject.figureType = valueFacesFacesItem["FigureType"].asString();
+		if(!valueFacesFacesItem["Age"].isNull())
+			facesObject.age = std::stol(valueFacesFacesItem["Age"].asString());
+		if(!valueFacesFacesItem["AgeSD"].isNull())
+			facesObject.ageSD = std::stof(valueFacesFacesItem["AgeSD"].asString());
 		if(!valueFacesFacesItem["Gender"].isNull())
 			facesObject.gender = valueFacesFacesItem["Gender"].asString();
 		if(!valueFacesFacesItem["GenderConfidence"].isNull())
 			facesObject.genderConfidence = std::stof(valueFacesFacesItem["GenderConfidence"].asString());
-		if(!valueFacesFacesItem["FaceId"].isNull())
-			facesObject.faceId = valueFacesFacesItem["FaceId"].asString();
-		if(!valueFacesFacesItem["FaceQuality"].isNull())
-			facesObject.faceQuality = std::stof(valueFacesFacesItem["FaceQuality"].asString());
 		if(!valueFacesFacesItem["Emotion"].isNull())
 			facesObject.emotion = valueFacesFacesItem["Emotion"].asString();
-		if(!valueFacesFacesItem["Age"].isNull())
-			facesObject.age = std::stoi(valueFacesFacesItem["Age"].asString());
-		if(!valueFacesFacesItem["FaceConfidence"].isNull())
-			facesObject.faceConfidence = std::stof(valueFacesFacesItem["FaceConfidence"].asString());
 		if(!valueFacesFacesItem["EmotionConfidence"].isNull())
 			facesObject.emotionConfidence = std::stof(valueFacesFacesItem["EmotionConfidence"].asString());
+		if(!valueFacesFacesItem["FaceQuality"].isNull())
+			facesObject.faceQuality = std::stof(valueFacesFacesItem["FaceQuality"].asString());
+		if(!valueFacesFacesItem["Mouth"].isNull())
+			facesObject.mouth = valueFacesFacesItem["Mouth"].asString();
+		if(!valueFacesFacesItem["MouthConfidence"].isNull())
+			facesObject.mouthConfidence = std::stof(valueFacesFacesItem["MouthConfidence"].asString());
+		if(!valueFacesFacesItem["Beard"].isNull())
+			facesObject.beard = valueFacesFacesItem["Beard"].asString();
+		if(!valueFacesFacesItem["BeardConfidence"].isNull())
+			facesObject.beardConfidence = std::stof(valueFacesFacesItem["BeardConfidence"].asString());
+		if(!valueFacesFacesItem["Hat"].isNull())
+			facesObject.hat = valueFacesFacesItem["Hat"].asString();
+		if(!valueFacesFacesItem["HatConfidence"].isNull())
+			facesObject.hatConfidence = std::stof(valueFacesFacesItem["HatConfidence"].asString());
+		if(!valueFacesFacesItem["Mask"].isNull())
+			facesObject.mask = valueFacesFacesItem["Mask"].asString();
+		if(!valueFacesFacesItem["MaskConfidence"].isNull())
+			facesObject.maskConfidence = std::stof(valueFacesFacesItem["MaskConfidence"].asString());
+		if(!valueFacesFacesItem["Glasses"].isNull())
+			facesObject.glasses = valueFacesFacesItem["Glasses"].asString();
+		if(!valueFacesFacesItem["GlassesConfidence"].isNull())
+			facesObject.glassesConfidence = std::stof(valueFacesFacesItem["GlassesConfidence"].asString());
+		if(!valueFacesFacesItem["Sharpness"].isNull())
+			facesObject.sharpness = std::stof(valueFacesFacesItem["Sharpness"].asString());
 		if(!valueFacesFacesItem["Attractive"].isNull())
 			facesObject.attractive = std::stof(valueFacesFacesItem["Attractive"].asString());
-		if(!valueFacesFacesItem["AgeConfidence"].isNull())
-			facesObject.ageConfidence = std::stof(valueFacesFacesItem["AgeConfidence"].asString());
-		auto faceAttributesNode = value["FaceAttributes"];
-		if(!faceAttributesNode["GlassesConfidence"].isNull())
-			facesObject.faceAttributes.glassesConfidence = std::stof(faceAttributesNode["GlassesConfidence"].asString());
-		if(!faceAttributesNode["Glasses"].isNull())
-			facesObject.faceAttributes.glasses = faceAttributesNode["Glasses"].asString();
-		if(!faceAttributesNode["Mask"].isNull())
-			facesObject.faceAttributes.mask = faceAttributesNode["Mask"].asString();
-		if(!faceAttributesNode["BeardConfidence"].isNull())
-			facesObject.faceAttributes.beardConfidence = std::stof(faceAttributesNode["BeardConfidence"].asString());
-		if(!faceAttributesNode["MaskConfidence"].isNull())
-			facesObject.faceAttributes.maskConfidence = std::stof(faceAttributesNode["MaskConfidence"].asString());
-		if(!faceAttributesNode["Beard"].isNull())
-			facesObject.faceAttributes.beard = faceAttributesNode["Beard"].asString();
-		auto faceBoundaryNode = faceAttributesNode["FaceBoundary"];
-		if(!faceBoundaryNode["Top"].isNull())
-			facesObject.faceAttributes.faceBoundary.top = std::stoi(faceBoundaryNode["Top"].asString());
-		if(!faceBoundaryNode["Width"].isNull())
-			facesObject.faceAttributes.faceBoundary.width = std::stoi(faceBoundaryNode["Width"].asString());
-		if(!faceBoundaryNode["Height"].isNull())
-			facesObject.faceAttributes.faceBoundary.height = std::stoi(faceBoundaryNode["Height"].asString());
-		if(!faceBoundaryNode["Left"].isNull())
-			facesObject.faceAttributes.faceBoundary.left = std::stoi(faceBoundaryNode["Left"].asString());
-		auto headPoseNode = faceAttributesNode["HeadPose"];
+		auto boundaryNode = value["Boundary"];
+		if(!boundaryNode["Width"].isNull())
+			facesObject.boundary.width = std::stol(boundaryNode["Width"].asString());
+		if(!boundaryNode["Height"].isNull())
+			facesObject.boundary.height = std::stol(boundaryNode["Height"].asString());
+		if(!boundaryNode["Left"].isNull())
+			facesObject.boundary.left = std::stol(boundaryNode["Left"].asString());
+		if(!boundaryNode["Top"].isNull())
+			facesObject.boundary.top = std::stol(boundaryNode["Top"].asString());
+		auto headPoseNode = value["HeadPose"];
 		if(!headPoseNode["Pitch"].isNull())
-			facesObject.faceAttributes.headPose.pitch = std::stof(headPoseNode["Pitch"].asString());
+			facesObject.headPose.pitch = std::stof(headPoseNode["Pitch"].asString());
 		if(!headPoseNode["Roll"].isNull())
-			facesObject.faceAttributes.headPose.roll = std::stof(headPoseNode["Roll"].asString());
+			facesObject.headPose.roll = std::stof(headPoseNode["Roll"].asString());
 		if(!headPoseNode["Yaw"].isNull())
-			facesObject.faceAttributes.headPose.yaw = std::stof(headPoseNode["Yaw"].asString());
-		auto emotionDetailsNode = value["EmotionDetails"];
-		if(!emotionDetailsNode["HAPPY"].isNull())
-			facesObject.emotionDetails.hAPPY = std::stof(emotionDetailsNode["HAPPY"].asString());
-		if(!emotionDetailsNode["CALM"].isNull())
-			facesObject.emotionDetails.cALM = std::stof(emotionDetailsNode["CALM"].asString());
-		if(!emotionDetailsNode["SURPRISED"].isNull())
-			facesObject.emotionDetails.sURPRISED = std::stof(emotionDetailsNode["SURPRISED"].asString());
-		if(!emotionDetailsNode["DISGUSTED"].isNull())
-			facesObject.emotionDetails.dISGUSTED = std::stof(emotionDetailsNode["DISGUSTED"].asString());
-		if(!emotionDetailsNode["ANGRY"].isNull())
-			facesObject.emotionDetails.aNGRY = std::stof(emotionDetailsNode["ANGRY"].asString());
-		if(!emotionDetailsNode["SAD"].isNull())
-			facesObject.emotionDetails.sAD = std::stof(emotionDetailsNode["SAD"].asString());
-		if(!emotionDetailsNode["SCARED"].isNull())
-			facesObject.emotionDetails.sCARED = std::stof(emotionDetailsNode["SCARED"].asString());
+			facesObject.headPose.yaw = std::stof(headPoseNode["Yaw"].asString());
 		faces_.push_back(facesObject);
 	}
-	if(!value["ImageUri"].isNull())
-		imageUri_ = value["ImageUri"].asString();
 
 }
 
-std::string DetectImageFacesResult::getImageUri()const
-{
-	return imageUri_;
-}
-
 std::vector<DetectImageFacesResult::FacesItem> DetectImageFacesResult::getFaces()const
 {
 	return faces_;

imm/src/model/DetectImageLabelsRequest.cc

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/DetectImageLabelsRequest.h>
+
+using AlibabaCloud::Imm::Model::DetectImageLabelsRequest;
+
+DetectImageLabelsRequest::DetectImageLabelsRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DetectImageLabels") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetectImageLabelsRequest::~DetectImageLabelsRequest() {}
+
+float DetectImageLabelsRequest::getThreshold() const {
+  return threshold_;
+}
+
+void DetectImageLabelsRequest::setThreshold(float threshold) {
+  threshold_ = threshold;
+  setParameter(std::string("Threshold"), std::to_string(threshold));
+}
+
+std::string DetectImageLabelsRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DetectImageLabelsRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+DetectImageLabelsRequest::CredentialConfig DetectImageLabelsRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void DetectImageLabelsRequest::setCredentialConfig(const DetectImageLabelsRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
+}
+
+std::string DetectImageLabelsRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void DetectImageLabelsRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/DetectImageLabelsResult.cc

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/DetectImageLabelsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DetectImageLabelsResult::DetectImageLabelsResult() :
+	ServiceResult()
+{}
+
+DetectImageLabelsResult::DetectImageLabelsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectImageLabelsResult::~DetectImageLabelsResult()
+{}
+
+void DetectImageLabelsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLabelsNode = value["Labels"]["LabelsItem"];
+	for (auto valueLabelsLabelsItem : allLabelsNode)
+	{
+		LabelsItem labelsObject;
+		if(!valueLabelsLabelsItem["Language"].isNull())
+			labelsObject.language = valueLabelsLabelsItem["Language"].asString();
+		if(!valueLabelsLabelsItem["LabelName"].isNull())
+			labelsObject.labelName = valueLabelsLabelsItem["LabelName"].asString();
+		if(!valueLabelsLabelsItem["LabelLevel"].isNull())
+			labelsObject.labelLevel = std::stol(valueLabelsLabelsItem["LabelLevel"].asString());
+		if(!valueLabelsLabelsItem["LabelConfidence"].isNull())
+			labelsObject.labelConfidence = std::stof(valueLabelsLabelsItem["LabelConfidence"].asString());
+		if(!valueLabelsLabelsItem["ParentLabelName"].isNull())
+			labelsObject.parentLabelName = valueLabelsLabelsItem["ParentLabelName"].asString();
+		if(!valueLabelsLabelsItem["CentricScore"].isNull())
+			labelsObject.centricScore = std::stof(valueLabelsLabelsItem["CentricScore"].asString());
+		labels_.push_back(labelsObject);
+	}
+
+}
+
+std::vector<DetectImageLabelsResult::LabelsItem> DetectImageLabelsResult::getLabels()const
+{
+	return labels_;
+}
+

imm/src/model/DetectImageQRCodesRequest.cc

@@ -1,54 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DetectImageQRCodesRequest.h>
-
-using AlibabaCloud::Imm::Model::DetectImageQRCodesRequest;
-
-DetectImageQRCodesRequest::DetectImageQRCodesRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DetectImageQRCodes") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DetectImageQRCodesRequest::~DetectImageQRCodesRequest() {}
-
-std::string DetectImageQRCodesRequest::getProject() const {
-  return project_;
-}
-
-void DetectImageQRCodesRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DetectImageQRCodesRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DetectImageQRCodesRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DetectImageQRCodesRequest::getImageUri() const {
-  return imageUri_;
-}
-
-void DetectImageQRCodesRequest::setImageUri(const std::string &imageUri) {
-  imageUri_ = imageUri;
-  setParameter(std::string("ImageUri"), imageUri);
-}
-

imm/src/model/DetectImageQRCodesResult.cc

@@ -1,73 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DetectImageQRCodesResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-DetectImageQRCodesResult::DetectImageQRCodesResult() :
-	ServiceResult()
-{}
-
-DetectImageQRCodesResult::DetectImageQRCodesResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DetectImageQRCodesResult::~DetectImageQRCodesResult()
-{}
-
-void DetectImageQRCodesResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allQRCodesNode = value["QRCodes"]["QRCodesItem"];
-	for (auto valueQRCodesQRCodesItem : allQRCodesNode)
-	{
-		QRCodesItem qRCodesObject;
-		if(!valueQRCodesQRCodesItem["Content"].isNull())
-			qRCodesObject.content = valueQRCodesQRCodesItem["Content"].asString();
-		auto qRCodeBoundaryNode = value["QRCodeBoundary"];
-		if(!qRCodeBoundaryNode["Top"].isNull())
-			qRCodesObject.qRCodeBoundary.top = std::stoi(qRCodeBoundaryNode["Top"].asString());
-		if(!qRCodeBoundaryNode["Width"].isNull())
-			qRCodesObject.qRCodeBoundary.width = std::stoi(qRCodeBoundaryNode["Width"].asString());
-		if(!qRCodeBoundaryNode["Height"].isNull())
-			qRCodesObject.qRCodeBoundary.height = std::stoi(qRCodeBoundaryNode["Height"].asString());
-		if(!qRCodeBoundaryNode["Left"].isNull())
-			qRCodesObject.qRCodeBoundary.left = std::stoi(qRCodeBoundaryNode["Left"].asString());
-		qRCodes_.push_back(qRCodesObject);
-	}
-	if(!value["ImageUri"].isNull())
-		imageUri_ = value["ImageUri"].asString();
-
-}
-
-std::string DetectImageQRCodesResult::getImageUri()const
-{
-	return imageUri_;
-}
-
-std::vector<DetectImageQRCodesResult::QRCodesItem> DetectImageQRCodesResult::getQRCodes()const
-{
-	return qRCodes_;
-}
-

imm/src/model/DetectImageScoreRequest.cc

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/DetectImageScoreRequest.h>
+
+using AlibabaCloud::Imm::Model::DetectImageScoreRequest;
+
+DetectImageScoreRequest::DetectImageScoreRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DetectImageScore") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetectImageScoreRequest::~DetectImageScoreRequest() {}
+
+std::string DetectImageScoreRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DetectImageScoreRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+DetectImageScoreRequest::CredentialConfig DetectImageScoreRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void DetectImageScoreRequest::setCredentialConfig(const DetectImageScoreRequest::CredentialConfig &credentialConfig) {
+  credentialConfig_ = credentialConfig;
+  for(int dep1 = 0; dep1 != credentialConfig.chain.size(); dep1++) {
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".Role", credentialConfig.chain[dep1].role);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".RoleType", credentialConfig.chain[dep1].roleType);
+    setParameter(std::string("CredentialConfig") + ".Chain." + std::to_string(dep1 + 1) + ".AssumeRoleFor", credentialConfig.chain[dep1].assumeRoleFor);
+  }
+  setParameter(std::string("CredentialConfig") + ".ServiceRole", credentialConfig.serviceRole);
+  setParameter(std::string("CredentialConfig") + ".Policy", credentialConfig.policy);
+}
+
+std::string DetectImageScoreRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void DetectImageScoreRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/DetectImageScoreResult.cc

@@ -14,45 +14,39 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/DeleteImageResult.h>
+#include <alibabacloud/imm/model/DetectImageScoreResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-DeleteImageResult::DeleteImageResult() :
+DetectImageScoreResult::DetectImageScoreResult() :
 	ServiceResult()
 {}
 
-DeleteImageResult::DeleteImageResult(const std::string &payload) :
+DetectImageScoreResult::DetectImageScoreResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteImageResult::~DeleteImageResult()
+DetectImageScoreResult::~DetectImageScoreResult()
 {}
 
-void DeleteImageResult::parse(const std::string &payload)
+void DetectImageScoreResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["SetId"].isNull())
-		setId_ = value["SetId"].asString();
-	if(!value["ImageUri"].isNull())
-		imageUri_ = value["ImageUri"].asString();
+	auto imageScoreNode = value["ImageScore"];
+	if(!imageScoreNode["OverallQualityScore"].isNull())
+		imageScore_.overallQualityScore = std::stof(imageScoreNode["OverallQualityScore"].asString());
 
 }
 
-std::string DeleteImageResult::getSetId()const
+DetectImageScoreResult::ImageScore DetectImageScoreResult::getImageScore()const
 {
-	return setId_;
-}
-
-std::string DeleteImageResult::getImageUri()const
-{
-	return imageUri_;
+	return imageScore_;
 }
 

imm/src/model/DetectImageTagsRequest.cc

@@ -1,63 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DetectImageTagsRequest.h>
-
-using AlibabaCloud::Imm::Model::DetectImageTagsRequest;
-
-DetectImageTagsRequest::DetectImageTagsRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DetectImageTags") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DetectImageTagsRequest::~DetectImageTagsRequest() {}
-
-std::string DetectImageTagsRequest::getProject() const {
-  return project_;
-}
-
-void DetectImageTagsRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DetectImageTagsRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DetectImageTagsRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DetectImageTagsRequest::getRealUid() const {
-  return realUid_;
-}
-
-void DetectImageTagsRequest::setRealUid(const std::string &realUid) {
-  realUid_ = realUid;
-  setParameter(std::string("RealUid"), realUid);
-}
-
-std::string DetectImageTagsRequest::getImageUri() const {
-  return imageUri_;
-}
-
-void DetectImageTagsRequest::setImageUri(const std::string &imageUri) {
-  imageUri_ = imageUri;
-  setParameter(std::string("ImageUri"), imageUri);
-}
-

imm/src/model/DetectImageTagsResult.cc

@@ -1,76 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DetectImageTagsResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-DetectImageTagsResult::DetectImageTagsResult() :
-	ServiceResult()
-{}
-
-DetectImageTagsResult::DetectImageTagsResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DetectImageTagsResult::~DetectImageTagsResult()
-{}
-
-void DetectImageTagsResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allTagsNode = value["Tags"]["TagsItem"];
-	for (auto valueTagsTagsItem : allTagsNode)
-	{
-		TagsItem tagsObject;
-		if(!valueTagsTagsItem["ParentTagEnName"].isNull())
-			tagsObject.parentTagEnName = valueTagsTagsItem["ParentTagEnName"].asString();
-		if(!valueTagsTagsItem["TagName"].isNull())
-			tagsObject.tagName = valueTagsTagsItem["TagName"].asString();
-		if(!valueTagsTagsItem["TagConfidence"].isNull())
-			tagsObject.tagConfidence = std::stof(valueTagsTagsItem["TagConfidence"].asString());
-		if(!valueTagsTagsItem["CentricScore"].isNull())
-			tagsObject.centricScore = std::stof(valueTagsTagsItem["CentricScore"].asString());
-		if(!valueTagsTagsItem["TagEnName"].isNull())
-			tagsObject.tagEnName = valueTagsTagsItem["TagEnName"].asString();
-		if(!valueTagsTagsItem["TagLevel"].isNull())
-			tagsObject.tagLevel = std::stoi(valueTagsTagsItem["TagLevel"].asString());
-		if(!valueTagsTagsItem["ParentTagName"].isNull())
-			tagsObject.parentTagName = valueTagsTagsItem["ParentTagName"].asString();
-		tags_.push_back(tagsObject);
-	}
-	if(!value["ImageUri"].isNull())
-		imageUri_ = value["ImageUri"].asString();
-
-}
-
-std::string DetectImageTagsResult::getImageUri()const
-{
-	return imageUri_;
-}
-
-std::vector<DetectImageTagsResult::TagsItem> DetectImageTagsResult::getTags()const
-{
-	return tags_;
-}
-

imm/src/model/DetectQRCodesRequest.cc

@@ -1,54 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DetectQRCodesRequest.h>
-
-using AlibabaCloud::Imm::Model::DetectQRCodesRequest;
-
-DetectQRCodesRequest::DetectQRCodesRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "DetectQRCodes") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DetectQRCodesRequest::~DetectQRCodesRequest() {}
-
-std::string DetectQRCodesRequest::getProject() const {
-  return project_;
-}
-
-void DetectQRCodesRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string DetectQRCodesRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void DetectQRCodesRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string DetectQRCodesRequest::getSrcUris() const {
-  return srcUris_;
-}
-
-void DetectQRCodesRequest::setSrcUris(const std::string &srcUris) {
-  srcUris_ = srcUris;
-  setParameter(std::string("SrcUris"), srcUris);
-}
-

imm/src/model/DetectQRCodesResult.cc

@@ -1,91 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/DetectQRCodesResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-DetectQRCodesResult::DetectQRCodesResult() :
-	ServiceResult()
-{}
-
-DetectQRCodesResult::DetectQRCodesResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DetectQRCodesResult::~DetectQRCodesResult()
-{}
-
-void DetectQRCodesResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allSuccessDetailsNode = value["SuccessDetails"]["SuccessDetailsItem"];
-	for (auto valueSuccessDetailsSuccessDetailsItem : allSuccessDetailsNode)
-	{
-		SuccessDetailsItem successDetailsObject;
-		if(!valueSuccessDetailsSuccessDetailsItem["SrcUri"].isNull())
-			successDetailsObject.srcUri = valueSuccessDetailsSuccessDetailsItem["SrcUri"].asString();
-		auto allQRCodesNode = valueSuccessDetailsSuccessDetailsItem["QRCodes"]["QRCodesItem"];
-		for (auto valueSuccessDetailsSuccessDetailsItemQRCodesQRCodesItem : allQRCodesNode)
-		{
-			SuccessDetailsItem::QRCodesItem qRCodesObject;
-			if(!valueSuccessDetailsSuccessDetailsItemQRCodesQRCodesItem["Content"].isNull())
-				qRCodesObject.content = valueSuccessDetailsSuccessDetailsItemQRCodesQRCodesItem["Content"].asString();
-			auto qRCodesRectangleNode = value["QRCodesRectangle"];
-			if(!qRCodesRectangleNode["Top"].isNull())
-				qRCodesObject.qRCodesRectangle.top = qRCodesRectangleNode["Top"].asString();
-			if(!qRCodesRectangleNode["Width"].isNull())
-				qRCodesObject.qRCodesRectangle.width = qRCodesRectangleNode["Width"].asString();
-			if(!qRCodesRectangleNode["Height"].isNull())
-				qRCodesObject.qRCodesRectangle.height = qRCodesRectangleNode["Height"].asString();
-			if(!qRCodesRectangleNode["Left"].isNull())
-				qRCodesObject.qRCodesRectangle.left = qRCodesRectangleNode["Left"].asString();
-			successDetailsObject.qRCodes.push_back(qRCodesObject);
-		}
-		successDetails_.push_back(successDetailsObject);
-	}
-	auto allFailDetailsNode = value["FailDetails"]["FailDetailsItem"];
-	for (auto valueFailDetailsFailDetailsItem : allFailDetailsNode)
-	{
-		FailDetailsItem failDetailsObject;
-		if(!valueFailDetailsFailDetailsItem["ErrorMessage"].isNull())
-			failDetailsObject.errorMessage = valueFailDetailsFailDetailsItem["ErrorMessage"].asString();
-		if(!valueFailDetailsFailDetailsItem["SrcUri"].isNull())
-			failDetailsObject.srcUri = valueFailDetailsFailDetailsItem["SrcUri"].asString();
-		if(!valueFailDetailsFailDetailsItem["ErrorCode"].isNull())
-			failDetailsObject.errorCode = valueFailDetailsFailDetailsItem["ErrorCode"].asString();
-		failDetails_.push_back(failDetailsObject);
-	}
-
-}
-
-std::vector<DetectQRCodesResult::SuccessDetailsItem> DetectQRCodesResult::getSuccessDetails()const
-{
-	return successDetails_;
-}
-
-std::vector<DetectQRCodesResult::FailDetailsItem> DetectQRCodesResult::getFailDetails()const
-{
-	return failDetails_;
-}
-

imm/src/model/DetectTextAnomalyRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/DetectTextAnomalyRequest.h>
+
+using AlibabaCloud::Imm::Model::DetectTextAnomalyRequest;
+
+DetectTextAnomalyRequest::DetectTextAnomalyRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DetectTextAnomaly") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetectTextAnomalyRequest::~DetectTextAnomalyRequest() {}
+
+std::string DetectTextAnomalyRequest::getContent() const {
+  return content_;
+}
+
+void DetectTextAnomalyRequest::setContent(const std::string &content) {
+  content_ = content;
+  setParameter(std::string("Content"), content);
+}
+
+std::string DetectTextAnomalyRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DetectTextAnomalyRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+

imm/src/model/DetectTextAnomalyResult.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/imm/model/DetectTextAnomalyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DetectTextAnomalyResult::DetectTextAnomalyResult() :
+	ServiceResult()
+{}
+
+DetectTextAnomalyResult::DetectTextAnomalyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectTextAnomalyResult::~DetectTextAnomalyResult()
+{}
+
+void DetectTextAnomalyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Suggestion"].isNull())
+		suggestion_ = value["Suggestion"].asString();
+
+}
+
+std::string DetectTextAnomalyResult::getSuggestion()const
+{
+	return suggestion_;
+}
+

imm/src/model/EncodeBlindWatermarkRequest.cc

@@ -1,117 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/EncodeBlindWatermarkRequest.h>
-
-using AlibabaCloud::Imm::Model::EncodeBlindWatermarkRequest;
-
-EncodeBlindWatermarkRequest::EncodeBlindWatermarkRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "EncodeBlindWatermark") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-EncodeBlindWatermarkRequest::~EncodeBlindWatermarkRequest() {}
-
-std::string EncodeBlindWatermarkRequest::getImageQuality() const {
-  return imageQuality_;
-}
-
-void EncodeBlindWatermarkRequest::setImageQuality(const std::string &imageQuality) {
-  imageQuality_ = imageQuality;
-  setParameter(std::string("ImageQuality"), imageQuality);
-}
-
-std::string EncodeBlindWatermarkRequest::getWatermarkUri() const {
-  return watermarkUri_;
-}
-
-void EncodeBlindWatermarkRequest::setWatermarkUri(const std::string &watermarkUri) {
-  watermarkUri_ = watermarkUri;
-  setParameter(std::string("WatermarkUri"), watermarkUri);
-}
-
-std::string EncodeBlindWatermarkRequest::getProject() const {
-  return project_;
-}
-
-void EncodeBlindWatermarkRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string EncodeBlindWatermarkRequest::getContent() const {
-  return content_;
-}
-
-void EncodeBlindWatermarkRequest::setContent(const std::string &content) {
-  content_ = content;
-  setParameter(std::string("Content"), content);
-}
-
-std::string EncodeBlindWatermarkRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void EncodeBlindWatermarkRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string EncodeBlindWatermarkRequest::getWatermarkType() const {
-  return watermarkType_;
-}
-
-void EncodeBlindWatermarkRequest::setWatermarkType(const std::string &watermarkType) {
-  watermarkType_ = watermarkType;
-  setParameter(std::string("WatermarkType"), watermarkType);
-}
-
-std::string EncodeBlindWatermarkRequest::getTargetUri() const {
-  return targetUri_;
-}
-
-void EncodeBlindWatermarkRequest::setTargetUri(const std::string &targetUri) {
-  targetUri_ = targetUri;
-  setParameter(std::string("TargetUri"), targetUri);
-}
-
-std::string EncodeBlindWatermarkRequest::getModel() const {
-  return model_;
-}
-
-void EncodeBlindWatermarkRequest::setModel(const std::string &model) {
-  model_ = model;
-  setParameter(std::string("Model"), model);
-}
-
-std::string EncodeBlindWatermarkRequest::getTargetImageType() const {
-  return targetImageType_;
-}
-
-void EncodeBlindWatermarkRequest::setTargetImageType(const std::string &targetImageType) {
-  targetImageType_ = targetImageType;
-  setParameter(std::string("TargetImageType"), targetImageType);
-}
-
-std::string EncodeBlindWatermarkRequest::getImageUri() const {
-  return imageUri_;
-}
-
-void EncodeBlindWatermarkRequest::setImageUri(const std::string &imageUri) {
-  imageUri_ = imageUri;
-  setParameter(std::string("ImageUri"), imageUri);
-}
-

imm/src/model/EncodeBlindWatermarkResult.cc

@@ -1,58 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/EncodeBlindWatermarkResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-EncodeBlindWatermarkResult::EncodeBlindWatermarkResult() :
-	ServiceResult()
-{}
-
-EncodeBlindWatermarkResult::EncodeBlindWatermarkResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-EncodeBlindWatermarkResult::~EncodeBlindWatermarkResult()
-{}
-
-void EncodeBlindWatermarkResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	if(!value["Content"].isNull())
-		content_ = value["Content"].asString();
-	if(!value["TargetUri"].isNull())
-		targetUri_ = value["TargetUri"].asString();
-
-}
-
-std::string EncodeBlindWatermarkResult::getContent()const
-{
-	return content_;
-}
-
-std::string EncodeBlindWatermarkResult::getTargetUri()const
-{
-	return targetUri_;
-}
-

imm/src/model/FindImagesRequest.cc

@@ -1,297 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/FindImagesRequest.h>
-
-using AlibabaCloud::Imm::Model::FindImagesRequest;
-
-FindImagesRequest::FindImagesRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "FindImages") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-FindImagesRequest::~FindImagesRequest() {}
-
-std::string FindImagesRequest::getRemarksArrayBIn() const {
-  return remarksArrayBIn_;
-}
-
-void FindImagesRequest::setRemarksArrayBIn(const std::string &remarksArrayBIn) {
-  remarksArrayBIn_ = remarksArrayBIn;
-  setParameter(std::string("RemarksArrayBIn"), remarksArrayBIn);
-}
-
-std::string FindImagesRequest::getProject() const {
-  return project_;
-}
-
-void FindImagesRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string FindImagesRequest::getExternalId() const {
-  return externalId_;
-}
-
-void FindImagesRequest::setExternalId(const std::string &externalId) {
-  externalId_ = externalId;
-  setParameter(std::string("ExternalId"), externalId);
-}
-
-std::string FindImagesRequest::getFacesModifyTimeRange() const {
-  return facesModifyTimeRange_;
-}
-
-void FindImagesRequest::setFacesModifyTimeRange(const std::string &facesModifyTimeRange) {
-  facesModifyTimeRange_ = facesModifyTimeRange;
-  setParameter(std::string("FacesModifyTimeRange"), facesModifyTimeRange);
-}
-
-std::string FindImagesRequest::getOCRContentsMatch() const {
-  return oCRContentsMatch_;
-}
-
-void FindImagesRequest::setOCRContentsMatch(const std::string &oCRContentsMatch) {
-  oCRContentsMatch_ = oCRContentsMatch;
-  setParameter(std::string("OCRContentsMatch"), oCRContentsMatch);
-}
-
-int FindImagesRequest::getLimit() const {
-  return limit_;
-}
-
-void FindImagesRequest::setLimit(int limit) {
-  limit_ = limit;
-  setParameter(std::string("Limit"), std::to_string(limit));
-}
-
-std::string FindImagesRequest::getRemarksDPrefix() const {
-  return remarksDPrefix_;
-}
-
-void FindImagesRequest::setRemarksDPrefix(const std::string &remarksDPrefix) {
-  remarksDPrefix_ = remarksDPrefix;
-  setParameter(std::string("RemarksDPrefix"), remarksDPrefix);
-}
-
-std::string FindImagesRequest::getSourceType() const {
-  return sourceType_;
-}
-
-void FindImagesRequest::setSourceType(const std::string &sourceType) {
-  sourceType_ = sourceType;
-  setParameter(std::string("SourceType"), sourceType);
-}
-
-std::string FindImagesRequest::getOrder() const {
-  return order_;
-}
-
-void FindImagesRequest::setOrder(const std::string &order) {
-  order_ = order;
-  setParameter(std::string("Order"), order);
-}
-
-std::string FindImagesRequest::getGroupId() const {
-  return groupId_;
-}
-
-void FindImagesRequest::setGroupId(const std::string &groupId) {
-  groupId_ = groupId;
-  setParameter(std::string("GroupId"), groupId);
-}
-
-std::string FindImagesRequest::getOrderBy() const {
-  return orderBy_;
-}
-
-void FindImagesRequest::setOrderBy(const std::string &orderBy) {
-  orderBy_ = orderBy;
-  setParameter(std::string("OrderBy"), orderBy);
-}
-
-std::string FindImagesRequest::getTagNames() const {
-  return tagNames_;
-}
-
-void FindImagesRequest::setTagNames(const std::string &tagNames) {
-  tagNames_ = tagNames;
-  setParameter(std::string("TagNames"), tagNames);
-}
-
-std::string FindImagesRequest::getMarker() const {
-  return marker_;
-}
-
-void FindImagesRequest::setMarker(const std::string &marker) {
-  marker_ = marker;
-  setParameter(std::string("Marker"), marker);
-}
-
-std::string FindImagesRequest::getRemarksCPrefix() const {
-  return remarksCPrefix_;
-}
-
-void FindImagesRequest::setRemarksCPrefix(const std::string &remarksCPrefix) {
-  remarksCPrefix_ = remarksCPrefix;
-  setParameter(std::string("RemarksCPrefix"), remarksCPrefix);
-}
-
-std::string FindImagesRequest::getModifyTimeRange() const {
-  return modifyTimeRange_;
-}
-
-void FindImagesRequest::setModifyTimeRange(const std::string &modifyTimeRange) {
-  modifyTimeRange_ = modifyTimeRange;
-  setParameter(std::string("ModifyTimeRange"), modifyTimeRange);
-}
-
-std::string FindImagesRequest::getAddressLineContentsMatch() const {
-  return addressLineContentsMatch_;
-}
-
-void FindImagesRequest::setAddressLineContentsMatch(const std::string &addressLineContentsMatch) {
-  addressLineContentsMatch_ = addressLineContentsMatch;
-  setParameter(std::string("AddressLineContentsMatch"), addressLineContentsMatch);
-}
-
-std::string FindImagesRequest::getGender() const {
-  return gender_;
-}
-
-void FindImagesRequest::setGender(const std::string &gender) {
-  gender_ = gender;
-  setParameter(std::string("Gender"), gender);
-}
-
-std::string FindImagesRequest::getRemarksArrayAIn() const {
-  return remarksArrayAIn_;
-}
-
-void FindImagesRequest::setRemarksArrayAIn(const std::string &remarksArrayAIn) {
-  remarksArrayAIn_ = remarksArrayAIn;
-  setParameter(std::string("RemarksArrayAIn"), remarksArrayAIn);
-}
-
-std::string FindImagesRequest::getImageSizeRange() const {
-  return imageSizeRange_;
-}
-
-void FindImagesRequest::setImageSizeRange(const std::string &imageSizeRange) {
-  imageSizeRange_ = imageSizeRange;
-  setParameter(std::string("ImageSizeRange"), imageSizeRange);
-}
-
-std::string FindImagesRequest::getRemarksBPrefix() const {
-  return remarksBPrefix_;
-}
-
-void FindImagesRequest::setRemarksBPrefix(const std::string &remarksBPrefix) {
-  remarksBPrefix_ = remarksBPrefix;
-  setParameter(std::string("RemarksBPrefix"), remarksBPrefix);
-}
-
-std::string FindImagesRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void FindImagesRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-std::string FindImagesRequest::getLocationBoundary() const {
-  return locationBoundary_;
-}
-
-void FindImagesRequest::setLocationBoundary(const std::string &locationBoundary) {
-  locationBoundary_ = locationBoundary;
-  setParameter(std::string("LocationBoundary"), locationBoundary);
-}
-
-std::string FindImagesRequest::getImageTimeRange() const {
-  return imageTimeRange_;
-}
-
-void FindImagesRequest::setImageTimeRange(const std::string &imageTimeRange) {
-  imageTimeRange_ = imageTimeRange;
-  setParameter(std::string("ImageTimeRange"), imageTimeRange);
-}
-
-std::string FindImagesRequest::getTagsModifyTimeRange() const {
-  return tagsModifyTimeRange_;
-}
-
-void FindImagesRequest::setTagsModifyTimeRange(const std::string &tagsModifyTimeRange) {
-  tagsModifyTimeRange_ = tagsModifyTimeRange;
-  setParameter(std::string("TagsModifyTimeRange"), tagsModifyTimeRange);
-}
-
-std::string FindImagesRequest::getAgeRange() const {
-  return ageRange_;
-}
-
-void FindImagesRequest::setAgeRange(const std::string &ageRange) {
-  ageRange_ = ageRange;
-  setParameter(std::string("AgeRange"), ageRange);
-}
-
-std::string FindImagesRequest::getRemarksAPrefix() const {
-  return remarksAPrefix_;
-}
-
-void FindImagesRequest::setRemarksAPrefix(const std::string &remarksAPrefix) {
-  remarksAPrefix_ = remarksAPrefix;
-  setParameter(std::string("RemarksAPrefix"), remarksAPrefix);
-}
-
-std::string FindImagesRequest::getSourceUriPrefix() const {
-  return sourceUriPrefix_;
-}
-
-void FindImagesRequest::setSourceUriPrefix(const std::string &sourceUriPrefix) {
-  sourceUriPrefix_ = sourceUriPrefix;
-  setParameter(std::string("SourceUriPrefix"), sourceUriPrefix);
-}
-
-std::string FindImagesRequest::getEmotion() const {
-  return emotion_;
-}
-
-void FindImagesRequest::setEmotion(const std::string &emotion) {
-  emotion_ = emotion;
-  setParameter(std::string("Emotion"), emotion);
-}
-
-std::string FindImagesRequest::getCreateTimeRange() const {
-  return createTimeRange_;
-}
-
-void FindImagesRequest::setCreateTimeRange(const std::string &createTimeRange) {
-  createTimeRange_ = createTimeRange;
-  setParameter(std::string("CreateTimeRange"), createTimeRange);
-}
-
-std::string FindImagesRequest::getSetId() const {
-  return setId_;
-}
-
-void FindImagesRequest::setSetId(const std::string &setId) {
-  setId_ = setId;
-  setParameter(std::string("SetId"), setId);
-}
-

imm/src/model/FindImagesResult.cc

@@ -1,305 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/FindImagesResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-FindImagesResult::FindImagesResult() :
-	ServiceResult()
-{}
-
-FindImagesResult::FindImagesResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-FindImagesResult::~FindImagesResult()
-{}
-
-void FindImagesResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allImagesNode = value["Images"]["ImagesItem"];
-	for (auto valueImagesImagesItem : allImagesNode)
-	{
-		ImagesItem imagesObject;
-		if(!valueImagesImagesItem["CroppingSuggestionStatus"].isNull())
-			imagesObject.croppingSuggestionStatus = valueImagesImagesItem["CroppingSuggestionStatus"].asString();
-		if(!valueImagesImagesItem["ImageQualityModifyTime"].isNull())
-			imagesObject.imageQualityModifyTime = valueImagesImagesItem["ImageQualityModifyTime"].asString();
-		if(!valueImagesImagesItem["TagsFailReason"].isNull())
-			imagesObject.tagsFailReason = valueImagesImagesItem["TagsFailReason"].asString();
-		if(!valueImagesImagesItem["RemarksC"].isNull())
-			imagesObject.remarksC = valueImagesImagesItem["RemarksC"].asString();
-		if(!valueImagesImagesItem["CreateTime"].isNull())
-			imagesObject.createTime = valueImagesImagesItem["CreateTime"].asString();
-		if(!valueImagesImagesItem["SourceType"].isNull())
-			imagesObject.sourceType = valueImagesImagesItem["SourceType"].asString();
-		if(!valueImagesImagesItem["FacesFailReason"].isNull())
-			imagesObject.facesFailReason = valueImagesImagesItem["FacesFailReason"].asString();
-		if(!valueImagesImagesItem["FacesModifyTime"].isNull())
-			imagesObject.facesModifyTime = valueImagesImagesItem["FacesModifyTime"].asString();
-		if(!valueImagesImagesItem["ImageTime"].isNull())
-			imagesObject.imageTime = valueImagesImagesItem["ImageTime"].asString();
-		if(!valueImagesImagesItem["OCRModifyTime"].isNull())
-			imagesObject.oCRModifyTime = valueImagesImagesItem["OCRModifyTime"].asString();
-		if(!valueImagesImagesItem["AddressModifyTime"].isNull())
-			imagesObject.addressModifyTime = valueImagesImagesItem["AddressModifyTime"].asString();
-		if(!valueImagesImagesItem["ImageQualityFailReason"].isNull())
-			imagesObject.imageQualityFailReason = valueImagesImagesItem["ImageQualityFailReason"].asString();
-		if(!valueImagesImagesItem["FacesStatus"].isNull())
-			imagesObject.facesStatus = valueImagesImagesItem["FacesStatus"].asString();
-		if(!valueImagesImagesItem["ImageHeight"].isNull())
-			imagesObject.imageHeight = std::stoi(valueImagesImagesItem["ImageHeight"].asString());
-		if(!valueImagesImagesItem["RemarksArrayA"].isNull())
-			imagesObject.remarksArrayA = valueImagesImagesItem["RemarksArrayA"].asString();
-		if(!valueImagesImagesItem["ExternalId"].isNull())
-			imagesObject.externalId = valueImagesImagesItem["ExternalId"].asString();
-		if(!valueImagesImagesItem["SourceUri"].isNull())
-			imagesObject.sourceUri = valueImagesImagesItem["SourceUri"].asString();
-		if(!valueImagesImagesItem["ModifyTime"].isNull())
-			imagesObject.modifyTime = valueImagesImagesItem["ModifyTime"].asString();
-		if(!valueImagesImagesItem["FileSize"].isNull())
-			imagesObject.fileSize = std::stoi(valueImagesImagesItem["FileSize"].asString());
-		if(!valueImagesImagesItem["SourcePosition"].isNull())
-			imagesObject.sourcePosition = valueImagesImagesItem["SourcePosition"].asString();
-		if(!valueImagesImagesItem["ImageQualityStatus"].isNull())
-			imagesObject.imageQualityStatus = valueImagesImagesItem["ImageQualityStatus"].asString();
-		if(!valueImagesImagesItem["OCRFailReason"].isNull())
-			imagesObject.oCRFailReason = valueImagesImagesItem["OCRFailReason"].asString();
-		if(!valueImagesImagesItem["AddressFailReason"].isNull())
-			imagesObject.addressFailReason = valueImagesImagesItem["AddressFailReason"].asString();
-		if(!valueImagesImagesItem["CroppingSuggestionModifyTime"].isNull())
-			imagesObject.croppingSuggestionModifyTime = valueImagesImagesItem["CroppingSuggestionModifyTime"].asString();
-		if(!valueImagesImagesItem["ImageFormat"].isNull())
-			imagesObject.imageFormat = valueImagesImagesItem["ImageFormat"].asString();
-		if(!valueImagesImagesItem["ImageWidth"].isNull())
-			imagesObject.imageWidth = std::stoi(valueImagesImagesItem["ImageWidth"].asString());
-		if(!valueImagesImagesItem["RemarksArrayB"].isNull())
-			imagesObject.remarksArrayB = valueImagesImagesItem["RemarksArrayB"].asString();
-		if(!valueImagesImagesItem["Orientation"].isNull())
-			imagesObject.orientation = valueImagesImagesItem["Orientation"].asString();
-		if(!valueImagesImagesItem["RemarksD"].isNull())
-			imagesObject.remarksD = valueImagesImagesItem["RemarksD"].asString();
-		if(!valueImagesImagesItem["TagsStatus"].isNull())
-			imagesObject.tagsStatus = valueImagesImagesItem["TagsStatus"].asString();
-		if(!valueImagesImagesItem["CroppingSuggestionFailReason"].isNull())
-			imagesObject.croppingSuggestionFailReason = valueImagesImagesItem["CroppingSuggestionFailReason"].asString();
-		if(!valueImagesImagesItem["RemarksA"].isNull())
-			imagesObject.remarksA = valueImagesImagesItem["RemarksA"].asString();
-		if(!valueImagesImagesItem["ImageUri"].isNull())
-			imagesObject.imageUri = valueImagesImagesItem["ImageUri"].asString();
-		if(!valueImagesImagesItem["TagsModifyTime"].isNull())
-			imagesObject.tagsModifyTime = valueImagesImagesItem["TagsModifyTime"].asString();
-		if(!valueImagesImagesItem["OCRStatus"].isNull())
-			imagesObject.oCRStatus = valueImagesImagesItem["OCRStatus"].asString();
-		if(!valueImagesImagesItem["AddressStatus"].isNull())
-			imagesObject.addressStatus = valueImagesImagesItem["AddressStatus"].asString();
-		if(!valueImagesImagesItem["Exif"].isNull())
-			imagesObject.exif = valueImagesImagesItem["Exif"].asString();
-		if(!valueImagesImagesItem["Location"].isNull())
-			imagesObject.location = valueImagesImagesItem["Location"].asString();
-		if(!valueImagesImagesItem["RemarksB"].isNull())
-			imagesObject.remarksB = valueImagesImagesItem["RemarksB"].asString();
-		auto allTagsNode = valueImagesImagesItem["Tags"]["TagsItem"];
-		for (auto valueImagesImagesItemTagsTagsItem : allTagsNode)
-		{
-			ImagesItem::TagsItem tagsObject;
-			if(!valueImagesImagesItemTagsTagsItem["TagConfidence"].isNull())
-				tagsObject.tagConfidence = std::stof(valueImagesImagesItemTagsTagsItem["TagConfidence"].asString());
-			if(!valueImagesImagesItemTagsTagsItem["CentricScore"].isNull())
-				tagsObject.centricScore = std::stof(valueImagesImagesItemTagsTagsItem["CentricScore"].asString());
-			if(!valueImagesImagesItemTagsTagsItem["TagName"].isNull())
-				tagsObject.tagName = valueImagesImagesItemTagsTagsItem["TagName"].asString();
-			if(!valueImagesImagesItemTagsTagsItem["TagLevel"].isNull())
-				tagsObject.tagLevel = std::stoi(valueImagesImagesItemTagsTagsItem["TagLevel"].asString());
-			if(!valueImagesImagesItemTagsTagsItem["ParentTagName"].isNull())
-				tagsObject.parentTagName = valueImagesImagesItemTagsTagsItem["ParentTagName"].asString();
-			imagesObject.tags.push_back(tagsObject);
-		}
-		auto allOCRNode = valueImagesImagesItem["OCR"]["OCRItem"];
-		for (auto valueImagesImagesItemOCROCRItem : allOCRNode)
-		{
-			ImagesItem::OCRItem oCRObject;
-			if(!valueImagesImagesItemOCROCRItem["OCRConfidence"].isNull())
-				oCRObject.oCRConfidence = std::stof(valueImagesImagesItemOCROCRItem["OCRConfidence"].asString());
-			if(!valueImagesImagesItemOCROCRItem["OCRContents"].isNull())
-				oCRObject.oCRContents = valueImagesImagesItemOCROCRItem["OCRContents"].asString();
-			auto oCRBoundaryNode = value["OCRBoundary"];
-			if(!oCRBoundaryNode["Top"].isNull())
-				oCRObject.oCRBoundary.top = std::stoi(oCRBoundaryNode["Top"].asString());
-			if(!oCRBoundaryNode["Width"].isNull())
-				oCRObject.oCRBoundary.width = std::stoi(oCRBoundaryNode["Width"].asString());
-			if(!oCRBoundaryNode["Height"].isNull())
-				oCRObject.oCRBoundary.height = std::stoi(oCRBoundaryNode["Height"].asString());
-			if(!oCRBoundaryNode["Left"].isNull())
-				oCRObject.oCRBoundary.left = std::stoi(oCRBoundaryNode["Left"].asString());
-			imagesObject.oCR.push_back(oCRObject);
-		}
-		auto allFacesNode = valueImagesImagesItem["Faces"]["FacesItem"];
-		for (auto valueImagesImagesItemFacesFacesItem : allFacesNode)
-		{
-			ImagesItem::FacesItem facesObject;
-			if(!valueImagesImagesItemFacesFacesItem["Gender"].isNull())
-				facesObject.gender = valueImagesImagesItemFacesFacesItem["Gender"].asString();
-			if(!valueImagesImagesItemFacesFacesItem["FaceId"].isNull())
-				facesObject.faceId = valueImagesImagesItemFacesFacesItem["FaceId"].asString();
-			if(!valueImagesImagesItemFacesFacesItem["GenderConfidence"].isNull())
-				facesObject.genderConfidence = std::stof(valueImagesImagesItemFacesFacesItem["GenderConfidence"].asString());
-			if(!valueImagesImagesItemFacesFacesItem["FaceQuality"].isNull())
-				facesObject.faceQuality = std::stof(valueImagesImagesItemFacesFacesItem["FaceQuality"].asString());
-			if(!valueImagesImagesItemFacesFacesItem["Emotion"].isNull())
-				facesObject.emotion = valueImagesImagesItemFacesFacesItem["Emotion"].asString();
-			if(!valueImagesImagesItemFacesFacesItem["Age"].isNull())
-				facesObject.age = std::stoi(valueImagesImagesItemFacesFacesItem["Age"].asString());
-			if(!valueImagesImagesItemFacesFacesItem["FaceConfidence"].isNull())
-				facesObject.faceConfidence = std::stof(valueImagesImagesItemFacesFacesItem["FaceConfidence"].asString());
-			if(!valueImagesImagesItemFacesFacesItem["EmotionConfidence"].isNull())
-				facesObject.emotionConfidence = std::stof(valueImagesImagesItemFacesFacesItem["EmotionConfidence"].asString());
-			if(!valueImagesImagesItemFacesFacesItem["Attractive"].isNull())
-				facesObject.attractive = std::stof(valueImagesImagesItemFacesFacesItem["Attractive"].asString());
-			if(!valueImagesImagesItemFacesFacesItem["GroupId"].isNull())
-				facesObject.groupId = valueImagesImagesItemFacesFacesItem["GroupId"].asString();
-			auto faceAttributesNode = value["FaceAttributes"];
-			if(!faceAttributesNode["GlassesConfidence"].isNull())
-				facesObject.faceAttributes.glassesConfidence = std::stof(faceAttributesNode["GlassesConfidence"].asString());
-			if(!faceAttributesNode["Glasses"].isNull())
-				facesObject.faceAttributes.glasses = faceAttributesNode["Glasses"].asString();
-			if(!faceAttributesNode["Mask"].isNull())
-				facesObject.faceAttributes.mask = faceAttributesNode["Mask"].asString();
-			if(!faceAttributesNode["BeardConfidence"].isNull())
-				facesObject.faceAttributes.beardConfidence = std::stof(faceAttributesNode["BeardConfidence"].asString());
-			if(!faceAttributesNode["MaskConfidence"].isNull())
-				facesObject.faceAttributes.maskConfidence = std::stof(faceAttributesNode["MaskConfidence"].asString());
-			if(!faceAttributesNode["Beard"].isNull())
-				facesObject.faceAttributes.beard = faceAttributesNode["Beard"].asString();
-			auto faceBoundaryNode = faceAttributesNode["FaceBoundary"];
-			if(!faceBoundaryNode["Top"].isNull())
-				facesObject.faceAttributes.faceBoundary.top = std::stoi(faceBoundaryNode["Top"].asString());
-			if(!faceBoundaryNode["Width"].isNull())
-				facesObject.faceAttributes.faceBoundary.width = std::stoi(faceBoundaryNode["Width"].asString());
-			if(!faceBoundaryNode["Height"].isNull())
-				facesObject.faceAttributes.faceBoundary.height = std::stoi(faceBoundaryNode["Height"].asString());
-			if(!faceBoundaryNode["Left"].isNull())
-				facesObject.faceAttributes.faceBoundary.left = std::stoi(faceBoundaryNode["Left"].asString());
-			auto headPoseNode = faceAttributesNode["HeadPose"];
-			if(!headPoseNode["Pitch"].isNull())
-				facesObject.faceAttributes.headPose.pitch = std::stof(headPoseNode["Pitch"].asString());
-			if(!headPoseNode["Roll"].isNull())
-				facesObject.faceAttributes.headPose.roll = std::stof(headPoseNode["Roll"].asString());
-			if(!headPoseNode["Yaw"].isNull())
-				facesObject.faceAttributes.headPose.yaw = std::stof(headPoseNode["Yaw"].asString());
-			auto emotionDetailsNode = value["EmotionDetails"];
-			if(!emotionDetailsNode["HAPPY"].isNull())
-				facesObject.emotionDetails.hAPPY = std::stof(emotionDetailsNode["HAPPY"].asString());
-			if(!emotionDetailsNode["SURPRISED"].isNull())
-				facesObject.emotionDetails.sURPRISED = std::stof(emotionDetailsNode["SURPRISED"].asString());
-			if(!emotionDetailsNode["CALM"].isNull())
-				facesObject.emotionDetails.cALM = std::stof(emotionDetailsNode["CALM"].asString());
-			if(!emotionDetailsNode["DISGUSTED"].isNull())
-				facesObject.emotionDetails.dISGUSTED = std::stof(emotionDetailsNode["DISGUSTED"].asString());
-			if(!emotionDetailsNode["ANGRY"].isNull())
-				facesObject.emotionDetails.aNGRY = std::stof(emotionDetailsNode["ANGRY"].asString());
-			if(!emotionDetailsNode["SAD"].isNull())
-				facesObject.emotionDetails.sAD = std::stof(emotionDetailsNode["SAD"].asString());
-			if(!emotionDetailsNode["SCARED"].isNull())
-				facesObject.emotionDetails.sCARED = std::stof(emotionDetailsNode["SCARED"].asString());
-			imagesObject.faces.push_back(facesObject);
-		}
-		auto allCroppingSuggestionNode = valueImagesImagesItem["CroppingSuggestion"]["CroppingSuggestionItem"];
-		for (auto valueImagesImagesItemCroppingSuggestionCroppingSuggestionItem : allCroppingSuggestionNode)
-		{
-			ImagesItem::CroppingSuggestionItem croppingSuggestionObject;
-			if(!valueImagesImagesItemCroppingSuggestionCroppingSuggestionItem["Score"].isNull())
-				croppingSuggestionObject.score = std::stof(valueImagesImagesItemCroppingSuggestionCroppingSuggestionItem["Score"].asString());
-			if(!valueImagesImagesItemCroppingSuggestionCroppingSuggestionItem["AspectRatio"].isNull())
-				croppingSuggestionObject.aspectRatio = valueImagesImagesItemCroppingSuggestionCroppingSuggestionItem["AspectRatio"].asString();
-			auto croppingBoundaryNode = value["CroppingBoundary"];
-			if(!croppingBoundaryNode["Top"].isNull())
-				croppingSuggestionObject.croppingBoundary.top = std::stoi(croppingBoundaryNode["Top"].asString());
-			if(!croppingBoundaryNode["Width"].isNull())
-				croppingSuggestionObject.croppingBoundary.width = std::stoi(croppingBoundaryNode["Width"].asString());
-			if(!croppingBoundaryNode["Height"].isNull())
-				croppingSuggestionObject.croppingBoundary.height = std::stoi(croppingBoundaryNode["Height"].asString());
-			if(!croppingBoundaryNode["Left"].isNull())
-				croppingSuggestionObject.croppingBoundary.left = std::stoi(croppingBoundaryNode["Left"].asString());
-			imagesObject.croppingSuggestion.push_back(croppingSuggestionObject);
-		}
-		auto addressNode = value["Address"];
-		if(!addressNode["Township"].isNull())
-			imagesObject.address.township = addressNode["Township"].asString();
-		if(!addressNode["District"].isNull())
-			imagesObject.address.district = addressNode["District"].asString();
-		if(!addressNode["AddressLine"].isNull())
-			imagesObject.address.addressLine = addressNode["AddressLine"].asString();
-		if(!addressNode["Country"].isNull())
-			imagesObject.address.country = addressNode["Country"].asString();
-		if(!addressNode["City"].isNull())
-			imagesObject.address.city = addressNode["City"].asString();
-		if(!addressNode["Province"].isNull())
-			imagesObject.address.province = addressNode["Province"].asString();
-		auto imageQualityNode = value["ImageQuality"];
-		if(!imageQualityNode["OverallScore"].isNull())
-			imagesObject.imageQuality.overallScore = std::stof(imageQualityNode["OverallScore"].asString());
-		if(!imageQualityNode["Color"].isNull())
-			imagesObject.imageQuality.color = std::stof(imageQualityNode["Color"].asString());
-		if(!imageQualityNode["ColorScore"].isNull())
-			imagesObject.imageQuality.colorScore = std::stof(imageQualityNode["ColorScore"].asString());
-		if(!imageQualityNode["ContrastScore"].isNull())
-			imagesObject.imageQuality.contrastScore = std::stof(imageQualityNode["ContrastScore"].asString());
-		if(!imageQualityNode["Contrast"].isNull())
-			imagesObject.imageQuality.contrast = std::stof(imageQualityNode["Contrast"].asString());
-		if(!imageQualityNode["ExposureScore"].isNull())
-			imagesObject.imageQuality.exposureScore = std::stof(imageQualityNode["ExposureScore"].asString());
-		if(!imageQualityNode["ClarityScore"].isNull())
-			imagesObject.imageQuality.clarityScore = std::stof(imageQualityNode["ClarityScore"].asString());
-		if(!imageQualityNode["Clarity"].isNull())
-			imagesObject.imageQuality.clarity = std::stof(imageQualityNode["Clarity"].asString());
-		if(!imageQualityNode["Exposure"].isNull())
-			imagesObject.imageQuality.exposure = std::stof(imageQualityNode["Exposure"].asString());
-		if(!imageQualityNode["CompositionScore"].isNull())
-			imagesObject.imageQuality.compositionScore = std::stof(imageQualityNode["CompositionScore"].asString());
-		images_.push_back(imagesObject);
-	}
-	if(!value["NextMarker"].isNull())
-		nextMarker_ = value["NextMarker"].asString();
-	if(!value["SetId"].isNull())
-		setId_ = value["SetId"].asString();
-
-}
-
-std::vector<FindImagesResult::ImagesItem> FindImagesResult::getImages()const
-{
-	return images_;
-}
-
-std::string FindImagesResult::getNextMarker()const
-{
-	return nextMarker_;
-}
-
-std::string FindImagesResult::getSetId()const
-{
-	return setId_;
-}
-

imm/src/model/FindSimilarFacesRequest.cc

@@ -1,99 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/FindSimilarFacesRequest.h>
-
-using AlibabaCloud::Imm::Model::FindSimilarFacesRequest;
-
-FindSimilarFacesRequest::FindSimilarFacesRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "FindSimilarFaces") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-FindSimilarFacesRequest::~FindSimilarFacesRequest() {}
-
-std::string FindSimilarFacesRequest::getProject() const {
-  return project_;
-}
-
-void FindSimilarFacesRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
-}
-
-std::string FindSimilarFacesRequest::getAccessKeyId() const {
-  return accessKeyId_;
-}
-
-void FindSimilarFacesRequest::setAccessKeyId(const std::string &accessKeyId) {
-  accessKeyId_ = accessKeyId;
-  setParameter(std::string("AccessKeyId"), accessKeyId);
-}
-
-float FindSimilarFacesRequest::getMinSimilarity() const {
-  return minSimilarity_;
-}
-
-void FindSimilarFacesRequest::setMinSimilarity(float minSimilarity) {
-  minSimilarity_ = minSimilarity;
-  setParameter(std::string("MinSimilarity"), std::to_string(minSimilarity));
-}
-
-std::string FindSimilarFacesRequest::getResponseFormat() const {
-  return responseFormat_;
-}
-
-void FindSimilarFacesRequest::setResponseFormat(const std::string &responseFormat) {
-  responseFormat_ = responseFormat;
-  setParameter(std::string("ResponseFormat"), responseFormat);
-}
-
-int FindSimilarFacesRequest::getLimit() const {
-  return limit_;
-}
-
-void FindSimilarFacesRequest::setLimit(int limit) {
-  limit_ = limit;
-  setParameter(std::string("Limit"), std::to_string(limit));
-}
-
-std::string FindSimilarFacesRequest::getFaceId() const {
-  return faceId_;
-}
-
-void FindSimilarFacesRequest::setFaceId(const std::string &faceId) {
-  faceId_ = faceId;
-  setParameter(std::string("FaceId"), faceId);
-}
-
-std::string FindSimilarFacesRequest::getImageUri() const {
-  return imageUri_;
-}
-
-void FindSimilarFacesRequest::setImageUri(const std::string &imageUri) {
-  imageUri_ = imageUri;
-  setParameter(std::string("ImageUri"), imageUri);
-}
-
-std::string FindSimilarFacesRequest::getSetId() const {
-  return setId_;
-}
-
-void FindSimilarFacesRequest::setSetId(const std::string &setId) {
-  setId_ = setId;
-  setParameter(std::string("SetId"), setId);
-}
-

imm/src/model/FindSimilarFacesResult.cc

@@ -1,97 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/imm/model/FindSimilarFacesResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-FindSimilarFacesResult::FindSimilarFacesResult() :
-	ServiceResult()
-{}
-
-FindSimilarFacesResult::FindSimilarFacesResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-FindSimilarFacesResult::~FindSimilarFacesResult()
-{}
-
-void FindSimilarFacesResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allFacesNode = value["Faces"]["FacesItem"];
-	for (auto valueFacesFacesItem : allFacesNode)
-	{
-		FacesItem facesObject;
-		if(!valueFacesFacesItem["FaceId"].isNull())
-			facesObject.faceId = valueFacesFacesItem["FaceId"].asString();
-		if(!valueFacesFacesItem["ImageUri"].isNull())
-			facesObject.imageUri = valueFacesFacesItem["ImageUri"].asString();
-		if(!valueFacesFacesItem["ExternalId"].isNull())
-			facesObject.externalId = valueFacesFacesItem["ExternalId"].asString();
-		if(!valueFacesFacesItem["Similarity"].isNull())
-			facesObject.similarity = std::stof(valueFacesFacesItem["Similarity"].asString());
-		auto allSimilarFacesNode = valueFacesFacesItem["SimilarFaces"]["SimilarFacesItem"];
-		for (auto valueFacesFacesItemSimilarFacesSimilarFacesItem : allSimilarFacesNode)
-		{
-			FacesItem::SimilarFacesItem similarFacesObject;
-			if(!valueFacesFacesItemSimilarFacesSimilarFacesItem["FaceId"].isNull())
-				similarFacesObject.faceId = valueFacesFacesItemSimilarFacesSimilarFacesItem["FaceId"].asString();
-			if(!valueFacesFacesItemSimilarFacesSimilarFacesItem["ImageUri"].isNull())
-				similarFacesObject.imageUri = valueFacesFacesItemSimilarFacesSimilarFacesItem["ImageUri"].asString();
-			if(!valueFacesFacesItemSimilarFacesSimilarFacesItem["ExternalId"].isNull())
-				similarFacesObject.externalId = valueFacesFacesItemSimilarFacesSimilarFacesItem["ExternalId"].asString();
-			if(!valueFacesFacesItemSimilarFacesSimilarFacesItem["Similarity"].isNull())
-				similarFacesObject.similarity = std::stof(valueFacesFacesItemSimilarFacesSimilarFacesItem["Similarity"].asString());
-			auto faceAttributes1Node = value["FaceAttributes"];
-			auto faceBoundaryNode = faceAttributes1Node["FaceBoundary"];
-			if(!faceBoundaryNode["Top"].isNull())
-				similarFacesObject.faceAttributes1.faceBoundary.top = std::stoi(faceBoundaryNode["Top"].asString());
-			if(!faceBoundaryNode["Width"].isNull())
-				similarFacesObject.faceAttributes1.faceBoundary.width = std::stoi(faceBoundaryNode["Width"].asString());
-			if(!faceBoundaryNode["Height"].isNull())
-				similarFacesObject.faceAttributes1.faceBoundary.height = std::stoi(faceBoundaryNode["Height"].asString());
-			if(!faceBoundaryNode["Left"].isNull())
-				similarFacesObject.faceAttributes1.faceBoundary.left = std::stoi(faceBoundaryNode["Left"].asString());
-			facesObject.similarFaces.push_back(similarFacesObject);
-		}
-		auto faceAttributesNode = value["FaceAttributes"];
-		auto faceBoundary2Node = faceAttributesNode["FaceBoundary"];
-		if(!faceBoundary2Node["Top"].isNull())
-			facesObject.faceAttributes.faceBoundary2.top = std::stoi(faceBoundary2Node["Top"].asString());
-		if(!faceBoundary2Node["Width"].isNull())
-			facesObject.faceAttributes.faceBoundary2.width = std::stoi(faceBoundary2Node["Width"].asString());
-		if(!faceBoundary2Node["Height"].isNull())
-			facesObject.faceAttributes.faceBoundary2.height = std::stoi(faceBoundary2Node["Height"].asString());
-		if(!faceBoundary2Node["Left"].isNull())
-			facesObject.faceAttributes.faceBoundary2.left = std::stoi(faceBoundary2Node["Left"].asString());
-		faces_.push_back(facesObject);
-	}
-
-}
-
-std::vector<FindSimilarFacesResult::FacesItem> FindSimilarFacesResult::getFaces()const
-{
-	return faces_;
-}
-

imm/src/model/FuzzyQueryRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imm/model/FuzzyQueryRequest.h>
+
+using AlibabaCloud::Imm::Model::FuzzyQueryRequest;
+
+FuzzyQueryRequest::FuzzyQueryRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "FuzzyQuery") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+FuzzyQueryRequest::~FuzzyQueryRequest() {}
+
+std::string FuzzyQueryRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void FuzzyQueryRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string FuzzyQueryRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void FuzzyQueryRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string FuzzyQueryRequest::getProjectName() const {
+  return projectName_;
+}
+
+void FuzzyQueryRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string FuzzyQueryRequest::getQuery() const {
+  return query_;
+}
+
+void FuzzyQueryRequest::setQuery(const std::string &query) {
+  query_ = query;
+  setParameter(std::string("Query"), query);
+}
+
+long FuzzyQueryRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void FuzzyQueryRequest::setMaxResults(long maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+