Update GenerateVideoPlaylist.

imm/src/model/AddImageMosaicRequest.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/AddImageMosaicRequest.h>
+
+using AlibabaCloud::Imm::Model::AddImageMosaicRequest;
+
+AddImageMosaicRequest::AddImageMosaicRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "AddImageMosaic") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddImageMosaicRequest::~AddImageMosaicRequest() {}
+
+std::vector<AddImageMosaicRequest::Targets> AddImageMosaicRequest::getTargets() const {
+  return targets_;
+}
+
+void AddImageMosaicRequest::setTargets(const std::vector<AddImageMosaicRequest::Targets> &targets) {
+  targets_ = targets;
+  for(int dep1 = 0; dep1 != targets.size(); dep1++) {
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Boundary.X", std::to_string(targets[dep1].boundary.x));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Boundary.Width", std::to_string(targets[dep1].boundary.width));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Boundary.Y", std::to_string(targets[dep1].boundary.y));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Boundary.ReferPos", targets[dep1].boundary.referPos);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Boundary.Height", std::to_string(targets[dep1].boundary.height));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Sigma", std::to_string(targets[dep1].sigma));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".BlurRadius", std::to_string(targets[dep1].blurRadius));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Color", targets[dep1].color);
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".MosaicRadius", std::to_string(targets[dep1].mosaicRadius));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Type", targets[dep1].type);
+  }
+}
+
+std::string AddImageMosaicRequest::getTargetURI() const {
+  return targetURI_;
+}
+
+void AddImageMosaicRequest::setTargetURI(const std::string &targetURI) {
+  targetURI_ = targetURI;
+  setParameter(std::string("TargetURI"), targetURI);
+}
+
+std::string AddImageMosaicRequest::getImageFormat() const {
+  return imageFormat_;
+}
+
+void AddImageMosaicRequest::setImageFormat(const std::string &imageFormat) {
+  imageFormat_ = imageFormat;
+  setParameter(std::string("ImageFormat"), imageFormat);
+}
+
+std::string AddImageMosaicRequest::getProjectName() const {
+  return projectName_;
+}
+
+void AddImageMosaicRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+AddImageMosaicRequest::CredentialConfig AddImageMosaicRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void AddImageMosaicRequest::setCredentialConfig(const AddImageMosaicRequest::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);
+}
+
+int AddImageMosaicRequest::getQuality() const {
+  return quality_;
+}
+
+void AddImageMosaicRequest::setQuality(int quality) {
+  quality_ = quality;
+  setParameter(std::string("Quality"), std::to_string(quality));
+}
+
+std::string AddImageMosaicRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void AddImageMosaicRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/AddImageMosaicResult.cc

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

imm/src/model/AddStoryFilesRequest.cc

@@ -25,15 +25,6 @@ AddStoryFilesRequest::AddStoryFilesRequest()
 
 AddStoryFilesRequest::~AddStoryFilesRequest() {}
 
-std::string AddStoryFilesRequest::getProjectName() const {
-  return projectName_;
-}
-
-void AddStoryFilesRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setBodyParameter(std::string("ProjectName"), projectName);
-}
-
 std::string AddStoryFilesRequest::getDatasetName() const {
   return datasetName_;
 }
@@ -43,6 +34,15 @@ void AddStoryFilesRequest::setDatasetName(const std::string &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_;
 }

imm/src/model/BatchDeleteFileMetaRequest.cc

@@ -25,15 +25,13 @@ BatchDeleteFileMetaRequest::BatchDeleteFileMetaRequest()
 
 BatchDeleteFileMetaRequest::~BatchDeleteFileMetaRequest() {}
 
-std::vector<BatchDeleteFileMetaRequest::std::string> BatchDeleteFileMetaRequest::getURIs() const {
-  return uRIs_;
+std::string BatchDeleteFileMetaRequest::getDatasetName() const {
+  return datasetName_;
 }
 
-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]);
-  }
+void BatchDeleteFileMetaRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
 }
 
 std::string BatchDeleteFileMetaRequest::getProjectName() const {
@@ -45,12 +43,14 @@ void BatchDeleteFileMetaRequest::setProjectName(const std::string &projectName)
   setParameter(std::string("ProjectName"), projectName);
 }
 
-std::string BatchDeleteFileMetaRequest::getDatasetName() const {
-  return datasetName_;
+std::vector<BatchDeleteFileMetaRequest::std::string> BatchDeleteFileMetaRequest::getURIs() const {
+  return uRIs_;
 }
 
-void BatchDeleteFileMetaRequest::setDatasetName(const std::string &datasetName) {
-  datasetName_ = datasetName;
-  setParameter(std::string("DatasetName"), datasetName);
+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/BatchGetFigureClusterRequest.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/BatchGetFigureClusterRequest.h>
+
+using AlibabaCloud::Imm::Model::BatchGetFigureClusterRequest;
+
+BatchGetFigureClusterRequest::BatchGetFigureClusterRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "BatchGetFigureCluster") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+BatchGetFigureClusterRequest::~BatchGetFigureClusterRequest() {}
+
+std::string BatchGetFigureClusterRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void BatchGetFigureClusterRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string BatchGetFigureClusterRequest::getProjectName() const {
+  return projectName_;
+}
+
+void BatchGetFigureClusterRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::vector<BatchGetFigureClusterRequest::std::string> BatchGetFigureClusterRequest::getObjectIds() const {
+  return objectIds_;
+}
+
+void BatchGetFigureClusterRequest::setObjectIds(const std::vector<BatchGetFigureClusterRequest::std::string> &objectIds) {
+  objectIds_ = objectIds;
+  for(int dep1 = 0; dep1 != objectIds.size(); dep1++) {
+    setParameter(std::string("ObjectIds") + "." + std::to_string(dep1 + 1), objectIds[dep1]);
+  }
+}
+

imm/src/model/BatchGetFigureClusterResult.cc

@@ -0,0 +1,568 @@
+/*
+ * 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/BatchGetFigureClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+BatchGetFigureClusterResult::BatchGetFigureClusterResult() :
+	ServiceResult()
+{}
+
+BatchGetFigureClusterResult::BatchGetFigureClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+BatchGetFigureClusterResult::~BatchGetFigureClusterResult()
+{}
+
+void BatchGetFigureClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFigureClustersNode = value["FigureClusters"]["FigureClustersItem"];
+	for (auto valueFigureClustersFigureClustersItem : allFigureClustersNode)
+	{
+		FigureClustersItem figureClustersObject;
+		if(!valueFigureClustersFigureClustersItem["OwnerId"].isNull())
+			figureClustersObject.ownerId = valueFigureClustersFigureClustersItem["OwnerId"].asString();
+		if(!valueFigureClustersFigureClustersItem["ProjectName"].isNull())
+			figureClustersObject.projectName = valueFigureClustersFigureClustersItem["ProjectName"].asString();
+		if(!valueFigureClustersFigureClustersItem["DatasetName"].isNull())
+			figureClustersObject.datasetName = valueFigureClustersFigureClustersItem["DatasetName"].asString();
+		if(!valueFigureClustersFigureClustersItem["ObjectType"].isNull())
+			figureClustersObject.objectType = valueFigureClustersFigureClustersItem["ObjectType"].asString();
+		if(!valueFigureClustersFigureClustersItem["ObjectId"].isNull())
+			figureClustersObject.objectId = valueFigureClustersFigureClustersItem["ObjectId"].asString();
+		if(!valueFigureClustersFigureClustersItem["UpdateTime"].isNull())
+			figureClustersObject.updateTime = valueFigureClustersFigureClustersItem["UpdateTime"].asString();
+		if(!valueFigureClustersFigureClustersItem["CreateTime"].isNull())
+			figureClustersObject.createTime = valueFigureClustersFigureClustersItem["CreateTime"].asString();
+		if(!valueFigureClustersFigureClustersItem["Name"].isNull())
+			figureClustersObject.name = valueFigureClustersFigureClustersItem["Name"].asString();
+		if(!valueFigureClustersFigureClustersItem["Gender"].isNull())
+			figureClustersObject.gender = valueFigureClustersFigureClustersItem["Gender"].asString();
+		if(!valueFigureClustersFigureClustersItem["FaceCount"].isNull())
+			figureClustersObject.faceCount = std::stol(valueFigureClustersFigureClustersItem["FaceCount"].asString());
+		if(!valueFigureClustersFigureClustersItem["ImageCount"].isNull())
+			figureClustersObject.imageCount = std::stol(valueFigureClustersFigureClustersItem["ImageCount"].asString());
+		if(!valueFigureClustersFigureClustersItem["VideoCount"].isNull())
+			figureClustersObject.videoCount = std::stol(valueFigureClustersFigureClustersItem["VideoCount"].asString());
+		if(!valueFigureClustersFigureClustersItem["AverageAge"].isNull())
+			figureClustersObject.averageAge = std::stof(valueFigureClustersFigureClustersItem["AverageAge"].asString());
+		if(!valueFigureClustersFigureClustersItem["MinAge"].isNull())
+			figureClustersObject.minAge = std::stof(valueFigureClustersFigureClustersItem["MinAge"].asString());
+		if(!valueFigureClustersFigureClustersItem["MaxAge"].isNull())
+			figureClustersObject.maxAge = std::stof(valueFigureClustersFigureClustersItem["MaxAge"].asString());
+		if(!valueFigureClustersFigureClustersItem["CustomId"].isNull())
+			figureClustersObject.customId = valueFigureClustersFigureClustersItem["CustomId"].asString();
+		if(!valueFigureClustersFigureClustersItem["CustomLabels"].isNull())
+			figureClustersObject.customLabels = valueFigureClustersFigureClustersItem["CustomLabels"].asString();
+		if(!valueFigureClustersFigureClustersItem["MetaLockVersion"].isNull())
+			figureClustersObject.metaLockVersion = std::stol(valueFigureClustersFigureClustersItem["MetaLockVersion"].asString());
+		auto coverNode = value["Cover"];
+		if(!coverNode["OwnerId"].isNull())
+			figureClustersObject.cover.ownerId = coverNode["OwnerId"].asString();
+		if(!coverNode["ProjectName"].isNull())
+			figureClustersObject.cover.projectName = coverNode["ProjectName"].asString();
+		if(!coverNode["DatasetName"].isNull())
+			figureClustersObject.cover.datasetName = coverNode["DatasetName"].asString();
+		if(!coverNode["ObjectType"].isNull())
+			figureClustersObject.cover.objectType = coverNode["ObjectType"].asString();
+		if(!coverNode["ObjectId"].isNull())
+			figureClustersObject.cover.objectId = coverNode["ObjectId"].asString();
+		if(!coverNode["UpdateTime"].isNull())
+			figureClustersObject.cover.updateTime = coverNode["UpdateTime"].asString();
+		if(!coverNode["CreateTime"].isNull())
+			figureClustersObject.cover.createTime = coverNode["CreateTime"].asString();
+		if(!coverNode["URI"].isNull())
+			figureClustersObject.cover.uRI = coverNode["URI"].asString();
+		if(!coverNode["OSSURI"].isNull())
+			figureClustersObject.cover.oSSURI = coverNode["OSSURI"].asString();
+		if(!coverNode["Filename"].isNull())
+			figureClustersObject.cover.filename = coverNode["Filename"].asString();
+		if(!coverNode["MediaType"].isNull())
+			figureClustersObject.cover.mediaType = coverNode["MediaType"].asString();
+		if(!coverNode["ContentType"].isNull())
+			figureClustersObject.cover.contentType = coverNode["ContentType"].asString();
+		if(!coverNode["Size"].isNull())
+			figureClustersObject.cover.size = std::stol(coverNode["Size"].asString());
+		if(!coverNode["FileHash"].isNull())
+			figureClustersObject.cover.fileHash = coverNode["FileHash"].asString();
+		if(!coverNode["FileModifiedTime"].isNull())
+			figureClustersObject.cover.fileModifiedTime = coverNode["FileModifiedTime"].asString();
+		if(!coverNode["FileCreateTime"].isNull())
+			figureClustersObject.cover.fileCreateTime = coverNode["FileCreateTime"].asString();
+		if(!coverNode["FileAccessTime"].isNull())
+			figureClustersObject.cover.fileAccessTime = coverNode["FileAccessTime"].asString();
+		if(!coverNode["ProduceTime"].isNull())
+			figureClustersObject.cover.produceTime = coverNode["ProduceTime"].asString();
+		if(!coverNode["LatLong"].isNull())
+			figureClustersObject.cover.latLong = coverNode["LatLong"].asString();
+		if(!coverNode["Timezone"].isNull())
+			figureClustersObject.cover.timezone = coverNode["Timezone"].asString();
+		if(!coverNode["TravelClusterId"].isNull())
+			figureClustersObject.cover.travelClusterId = coverNode["TravelClusterId"].asString();
+		if(!coverNode["Orientation"].isNull())
+			figureClustersObject.cover.orientation = std::stol(coverNode["Orientation"].asString());
+		if(!coverNode["FigureCount"].isNull())
+			figureClustersObject.cover.figureCount = std::stol(coverNode["FigureCount"].asString());
+		if(!coverNode["Title"].isNull())
+			figureClustersObject.cover.title = coverNode["Title"].asString();
+		if(!coverNode["ImageWidth"].isNull())
+			figureClustersObject.cover.imageWidth = std::stol(coverNode["ImageWidth"].asString());
+		if(!coverNode["ImageHeight"].isNull())
+			figureClustersObject.cover.imageHeight = std::stol(coverNode["ImageHeight"].asString());
+		if(!coverNode["EXIF"].isNull())
+			figureClustersObject.cover.eXIF = coverNode["EXIF"].asString();
+		if(!coverNode["VideoWidth"].isNull())
+			figureClustersObject.cover.videoWidth = std::stol(coverNode["VideoWidth"].asString());
+		if(!coverNode["VideoHeight"].isNull())
+			figureClustersObject.cover.videoHeight = std::stol(coverNode["VideoHeight"].asString());
+		if(!coverNode["Artist"].isNull())
+			figureClustersObject.cover.artist = coverNode["Artist"].asString();
+		if(!coverNode["AlbumArtist"].isNull())
+			figureClustersObject.cover.albumArtist = coverNode["AlbumArtist"].asString();
+		if(!coverNode["Composer"].isNull())
+			figureClustersObject.cover.composer = coverNode["Composer"].asString();
+		if(!coverNode["Performer"].isNull())
+			figureClustersObject.cover.performer = coverNode["Performer"].asString();
+		if(!coverNode["Language"].isNull())
+			figureClustersObject.cover.language = coverNode["Language"].asString();
+		if(!coverNode["Album"].isNull())
+			figureClustersObject.cover.album = coverNode["Album"].asString();
+		if(!coverNode["DocumentLanguage"].isNull())
+			figureClustersObject.cover.documentLanguage = coverNode["DocumentLanguage"].asString();
+		if(!coverNode["PageCount"].isNull())
+			figureClustersObject.cover.pageCount = std::stol(coverNode["PageCount"].asString());
+		if(!coverNode["DocumentContent"].isNull())
+			figureClustersObject.cover.documentContent = coverNode["DocumentContent"].asString();
+		if(!coverNode["ETag"].isNull())
+			figureClustersObject.cover.eTag = coverNode["ETag"].asString();
+		if(!coverNode["CacheControl"].isNull())
+			figureClustersObject.cover.cacheControl = coverNode["CacheControl"].asString();
+		if(!coverNode["ContentDisposition"].isNull())
+			figureClustersObject.cover.contentDisposition = coverNode["ContentDisposition"].asString();
+		if(!coverNode["ContentEncoding"].isNull())
+			figureClustersObject.cover.contentEncoding = coverNode["ContentEncoding"].asString();
+		if(!coverNode["ContentLanguage"].isNull())
+			figureClustersObject.cover.contentLanguage = coverNode["ContentLanguage"].asString();
+		if(!coverNode["AccessControlAllowOrigin"].isNull())
+			figureClustersObject.cover.accessControlAllowOrigin = coverNode["AccessControlAllowOrigin"].asString();
+		if(!coverNode["AccessControlRequestMethod"].isNull())
+			figureClustersObject.cover.accessControlRequestMethod = coverNode["AccessControlRequestMethod"].asString();
+		if(!coverNode["ServerSideEncryptionCustomerAlgorithm"].isNull())
+			figureClustersObject.cover.serverSideEncryptionCustomerAlgorithm = coverNode["ServerSideEncryptionCustomerAlgorithm"].asString();
+		if(!coverNode["ServerSideEncryption"].isNull())
+			figureClustersObject.cover.serverSideEncryption = coverNode["ServerSideEncryption"].asString();
+		if(!coverNode["ServerSideDataEncryption"].isNull())
+			figureClustersObject.cover.serverSideDataEncryption = coverNode["ServerSideDataEncryption"].asString();
+		if(!coverNode["ServerSideEncryptionKeyId"].isNull())
+			figureClustersObject.cover.serverSideEncryptionKeyId = coverNode["ServerSideEncryptionKeyId"].asString();
+		if(!coverNode["OSSStorageClass"].isNull())
+			figureClustersObject.cover.oSSStorageClass = coverNode["OSSStorageClass"].asString();
+		if(!coverNode["OSSCRC64"].isNull())
+			figureClustersObject.cover.oSSCRC64 = coverNode["OSSCRC64"].asString();
+		if(!coverNode["ObjectACL"].isNull())
+			figureClustersObject.cover.objectACL = coverNode["ObjectACL"].asString();
+		if(!coverNode["ContentMd5"].isNull())
+			figureClustersObject.cover.contentMd5 = coverNode["ContentMd5"].asString();
+		if(!coverNode["OSSUserMeta"].isNull())
+			figureClustersObject.cover.oSSUserMeta = coverNode["OSSUserMeta"].asString();
+		if(!coverNode["OSSTaggingCount"].isNull())
+			figureClustersObject.cover.oSSTaggingCount = std::stol(coverNode["OSSTaggingCount"].asString());
+		if(!coverNode["OSSTagging"].isNull())
+			figureClustersObject.cover.oSSTagging = coverNode["OSSTagging"].asString();
+		if(!coverNode["OSSExpiration"].isNull())
+			figureClustersObject.cover.oSSExpiration = coverNode["OSSExpiration"].asString();
+		if(!coverNode["OSSVersionId"].isNull())
+			figureClustersObject.cover.oSSVersionId = coverNode["OSSVersionId"].asString();
+		if(!coverNode["OSSDeleteMarker"].isNull())
+			figureClustersObject.cover.oSSDeleteMarker = coverNode["OSSDeleteMarker"].asString();
+		if(!coverNode["OSSObjectType"].isNull())
+			figureClustersObject.cover.oSSObjectType = coverNode["OSSObjectType"].asString();
+		if(!coverNode["CustomId"].isNull())
+			figureClustersObject.cover.customId = coverNode["CustomId"].asString();
+		if(!coverNode["CustomLabels"].isNull())
+			figureClustersObject.cover.customLabels = coverNode["CustomLabels"].asString();
+		if(!coverNode["StreamCount"].isNull())
+			figureClustersObject.cover.streamCount = std::stol(coverNode["StreamCount"].asString());
+		if(!coverNode["ProgramCount"].isNull())
+			figureClustersObject.cover.programCount = std::stol(coverNode["ProgramCount"].asString());
+		if(!coverNode["FormatName"].isNull())
+			figureClustersObject.cover.formatName = coverNode["FormatName"].asString();
+		if(!coverNode["FormatLongName"].isNull())
+			figureClustersObject.cover.formatLongName = coverNode["FormatLongName"].asString();
+		if(!coverNode["StartTime"].isNull())
+			figureClustersObject.cover.startTime = coverNode["StartTime"].asString();
+		if(!coverNode["Bitrate"].isNull())
+			figureClustersObject.cover.bitrate = std::stol(coverNode["Bitrate"].asString());
+		if(!coverNode["Duration"].isNull())
+			figureClustersObject.cover.duration = coverNode["Duration"].asString();
+		auto allAddressesNode = coverNode["Addresses"]["AddressesItem"];
+		for (auto coverNodeAddressesAddressesItem : allAddressesNode)
+		{
+			FigureClustersItem::Cover::AddressesItem addressesItemObject;
+			if(!coverNodeAddressesAddressesItem["Language"].isNull())
+				addressesItemObject.language = coverNodeAddressesAddressesItem["Language"].asString();
+			if(!coverNodeAddressesAddressesItem["AddressLine"].isNull())
+				addressesItemObject.addressLine = coverNodeAddressesAddressesItem["AddressLine"].asString();
+			if(!coverNodeAddressesAddressesItem["Country"].isNull())
+				addressesItemObject.country = coverNodeAddressesAddressesItem["Country"].asString();
+			if(!coverNodeAddressesAddressesItem["Province"].isNull())
+				addressesItemObject.province = coverNodeAddressesAddressesItem["Province"].asString();
+			if(!coverNodeAddressesAddressesItem["City"].isNull())
+				addressesItemObject.city = coverNodeAddressesAddressesItem["City"].asString();
+			if(!coverNodeAddressesAddressesItem["District"].isNull())
+				addressesItemObject.district = coverNodeAddressesAddressesItem["District"].asString();
+			if(!coverNodeAddressesAddressesItem["Township"].isNull())
+				addressesItemObject.township = coverNodeAddressesAddressesItem["Township"].asString();
+			figureClustersObject.cover.addresses.push_back(addressesItemObject);
+		}
+		auto allFiguresNode = coverNode["Figures"]["FiguresItem"];
+		for (auto coverNodeFiguresFiguresItem : allFiguresNode)
+		{
+			FigureClustersItem::Cover::FiguresItem figuresItemObject;
+			if(!coverNodeFiguresFiguresItem["FigureId"].isNull())
+				figuresItemObject.figureId = coverNodeFiguresFiguresItem["FigureId"].asString();
+			if(!coverNodeFiguresFiguresItem["FigureConfidence"].isNull())
+				figuresItemObject.figureConfidence = std::stof(coverNodeFiguresFiguresItem["FigureConfidence"].asString());
+			if(!coverNodeFiguresFiguresItem["FigureClusterId"].isNull())
+				figuresItemObject.figureClusterId = coverNodeFiguresFiguresItem["FigureClusterId"].asString();
+			if(!coverNodeFiguresFiguresItem["FigureClusterConfidence"].isNull())
+				figuresItemObject.figureClusterConfidence = std::stof(coverNodeFiguresFiguresItem["FigureClusterConfidence"].asString());
+			if(!coverNodeFiguresFiguresItem["FigureType"].isNull())
+				figuresItemObject.figureType = coverNodeFiguresFiguresItem["FigureType"].asString();
+			if(!coverNodeFiguresFiguresItem["Age"].isNull())
+				figuresItemObject.age = std::stol(coverNodeFiguresFiguresItem["Age"].asString());
+			if(!coverNodeFiguresFiguresItem["AgeSD"].isNull())
+				figuresItemObject.ageSD = std::stof(coverNodeFiguresFiguresItem["AgeSD"].asString());
+			if(!coverNodeFiguresFiguresItem["Gender"].isNull())
+				figuresItemObject.gender = coverNodeFiguresFiguresItem["Gender"].asString();
+			if(!coverNodeFiguresFiguresItem["GenderConfidence"].isNull())
+				figuresItemObject.genderConfidence = std::stof(coverNodeFiguresFiguresItem["GenderConfidence"].asString());
+			if(!coverNodeFiguresFiguresItem["Emotion"].isNull())
+				figuresItemObject.emotion = coverNodeFiguresFiguresItem["Emotion"].asString();
+			if(!coverNodeFiguresFiguresItem["EmotionConfidence"].isNull())
+				figuresItemObject.emotionConfidence = std::stof(coverNodeFiguresFiguresItem["EmotionConfidence"].asString());
+			if(!coverNodeFiguresFiguresItem["FaceQuality"].isNull())
+				figuresItemObject.faceQuality = std::stof(coverNodeFiguresFiguresItem["FaceQuality"].asString());
+			if(!coverNodeFiguresFiguresItem["Mouth"].isNull())
+				figuresItemObject.mouth = coverNodeFiguresFiguresItem["Mouth"].asString();
+			if(!coverNodeFiguresFiguresItem["MouthConfidence"].isNull())
+				figuresItemObject.mouthConfidence = std::stof(coverNodeFiguresFiguresItem["MouthConfidence"].asString());
+			if(!coverNodeFiguresFiguresItem["Beard"].isNull())
+				figuresItemObject.beard = coverNodeFiguresFiguresItem["Beard"].asString();
+			if(!coverNodeFiguresFiguresItem["BeardConfidence"].isNull())
+				figuresItemObject.beardConfidence = std::stof(coverNodeFiguresFiguresItem["BeardConfidence"].asString());
+			if(!coverNodeFiguresFiguresItem["Hat"].isNull())
+				figuresItemObject.hat = coverNodeFiguresFiguresItem["Hat"].asString();
+			if(!coverNodeFiguresFiguresItem["HatConfidence"].isNull())
+				figuresItemObject.hatConfidence = std::stof(coverNodeFiguresFiguresItem["HatConfidence"].asString());
+			if(!coverNodeFiguresFiguresItem["Mask"].isNull())
+				figuresItemObject.mask = coverNodeFiguresFiguresItem["Mask"].asString();
+			if(!coverNodeFiguresFiguresItem["MaskConfidence"].isNull())
+				figuresItemObject.maskConfidence = std::stof(coverNodeFiguresFiguresItem["MaskConfidence"].asString());
+			if(!coverNodeFiguresFiguresItem["Glasses"].isNull())
+				figuresItemObject.glasses = coverNodeFiguresFiguresItem["Glasses"].asString();
+			if(!coverNodeFiguresFiguresItem["GlassesConfidence"].isNull())
+				figuresItemObject.glassesConfidence = std::stof(coverNodeFiguresFiguresItem["GlassesConfidence"].asString());
+			if(!coverNodeFiguresFiguresItem["Sharpness"].isNull())
+				figuresItemObject.sharpness = std::stof(coverNodeFiguresFiguresItem["Sharpness"].asString());
+			if(!coverNodeFiguresFiguresItem["Attractive"].isNull())
+				figuresItemObject.attractive = std::stof(coverNodeFiguresFiguresItem["Attractive"].asString());
+			auto boundaryNode = value["Boundary"];
+			if(!boundaryNode["Width"].isNull())
+				figuresItemObject.boundary.width = std::stol(boundaryNode["Width"].asString());
+			if(!boundaryNode["Height"].isNull())
+				figuresItemObject.boundary.height = std::stol(boundaryNode["Height"].asString());
+			if(!boundaryNode["Left"].isNull())
+				figuresItemObject.boundary.left = std::stol(boundaryNode["Left"].asString());
+			if(!boundaryNode["Top"].isNull())
+				figuresItemObject.boundary.top = std::stol(boundaryNode["Top"].asString());
+			auto headPoseNode = value["HeadPose"];
+			if(!headPoseNode["Pitch"].isNull())
+				figuresItemObject.headPose.pitch = std::stof(headPoseNode["Pitch"].asString());
+			if(!headPoseNode["Roll"].isNull())
+				figuresItemObject.headPose.roll = std::stof(headPoseNode["Roll"].asString());
+			if(!headPoseNode["Yaw"].isNull())
+				figuresItemObject.headPose.yaw = std::stof(headPoseNode["Yaw"].asString());
+			figureClustersObject.cover.figures.push_back(figuresItemObject);
+		}
+		auto allLabelsNode = coverNode["Labels"]["LabelsItem"];
+		for (auto coverNodeLabelsLabelsItem : allLabelsNode)
+		{
+			FigureClustersItem::Cover::LabelsItem labelsItemObject;
+			if(!coverNodeLabelsLabelsItem["Language"].isNull())
+				labelsItemObject.language = coverNodeLabelsLabelsItem["Language"].asString();
+			if(!coverNodeLabelsLabelsItem["LabelName"].isNull())
+				labelsItemObject.labelName = coverNodeLabelsLabelsItem["LabelName"].asString();
+			if(!coverNodeLabelsLabelsItem["LabelLevel"].isNull())
+				labelsItemObject.labelLevel = std::stol(coverNodeLabelsLabelsItem["LabelLevel"].asString());
+			if(!coverNodeLabelsLabelsItem["LabelConfidence"].isNull())
+				labelsItemObject.labelConfidence = std::stof(coverNodeLabelsLabelsItem["LabelConfidence"].asString());
+			if(!coverNodeLabelsLabelsItem["ParentLabelName"].isNull())
+				labelsItemObject.parentLabelName = coverNodeLabelsLabelsItem["ParentLabelName"].asString();
+			if(!coverNodeLabelsLabelsItem["CentricScore"].isNull())
+				labelsItemObject.centricScore = std::stof(coverNodeLabelsLabelsItem["CentricScore"].asString());
+			figureClustersObject.cover.labels.push_back(labelsItemObject);
+		}
+		auto allCroppingSuggestionsNode = coverNode["CroppingSuggestions"]["CroppingSuggestionsItem"];
+		for (auto coverNodeCroppingSuggestionsCroppingSuggestionsItem : allCroppingSuggestionsNode)
+		{
+			FigureClustersItem::Cover::CroppingSuggestionsItem croppingSuggestionsItemObject;
+			if(!coverNodeCroppingSuggestionsCroppingSuggestionsItem["AspectRatio"].isNull())
+				croppingSuggestionsItemObject.aspectRatio = coverNodeCroppingSuggestionsCroppingSuggestionsItem["AspectRatio"].asString();
+			if(!coverNodeCroppingSuggestionsCroppingSuggestionsItem["Confidence"].isNull())
+				croppingSuggestionsItemObject.confidence = std::stof(coverNodeCroppingSuggestionsCroppingSuggestionsItem["Confidence"].asString());
+			auto boundary1Node = value["Boundary"];
+			if(!boundary1Node["Width"].isNull())
+				croppingSuggestionsItemObject.boundary1.width = std::stol(boundary1Node["Width"].asString());
+			if(!boundary1Node["Height"].isNull())
+				croppingSuggestionsItemObject.boundary1.height = std::stol(boundary1Node["Height"].asString());
+			if(!boundary1Node["Left"].isNull())
+				croppingSuggestionsItemObject.boundary1.left = std::stol(boundary1Node["Left"].asString());
+			if(!boundary1Node["Top"].isNull())
+				croppingSuggestionsItemObject.boundary1.top = std::stol(boundary1Node["Top"].asString());
+			figureClustersObject.cover.croppingSuggestions.push_back(croppingSuggestionsItemObject);
+		}
+		auto allOCRContentsNode = coverNode["OCRContents"]["OCRContentsItem"];
+		for (auto coverNodeOCRContentsOCRContentsItem : allOCRContentsNode)
+		{
+			FigureClustersItem::Cover::OCRContentsItem oCRContentsItemObject;
+			if(!coverNodeOCRContentsOCRContentsItem["Language"].isNull())
+				oCRContentsItemObject.language = coverNodeOCRContentsOCRContentsItem["Language"].asString();
+			if(!coverNodeOCRContentsOCRContentsItem["Contents"].isNull())
+				oCRContentsItemObject.contents = coverNodeOCRContentsOCRContentsItem["Contents"].asString();
+			if(!coverNodeOCRContentsOCRContentsItem["Confidence"].isNull())
+				oCRContentsItemObject.confidence = std::stof(coverNodeOCRContentsOCRContentsItem["Confidence"].asString());
+			auto boundary2Node = value["Boundary"];
+			if(!boundary2Node["Width"].isNull())
+				oCRContentsItemObject.boundary2.width = std::stol(boundary2Node["Width"].asString());
+			if(!boundary2Node["Height"].isNull())
+				oCRContentsItemObject.boundary2.height = std::stol(boundary2Node["Height"].asString());
+			if(!boundary2Node["Left"].isNull())
+				oCRContentsItemObject.boundary2.left = std::stol(boundary2Node["Left"].asString());
+			if(!boundary2Node["Top"].isNull())
+				oCRContentsItemObject.boundary2.top = std::stol(boundary2Node["Top"].asString());
+			figureClustersObject.cover.oCRContents.push_back(oCRContentsItemObject);
+		}
+		auto allVideoStreamsNode = coverNode["VideoStreams"]["VideoStreamsItem"];
+		for (auto coverNodeVideoStreamsVideoStreamsItem : allVideoStreamsNode)
+		{
+			FigureClustersItem::Cover::VideoStreamsItem videoStreamsItemObject;
+			if(!coverNodeVideoStreamsVideoStreamsItem["Index"].isNull())
+				videoStreamsItemObject.index = std::stol(coverNodeVideoStreamsVideoStreamsItem["Index"].asString());
+			if(!coverNodeVideoStreamsVideoStreamsItem["Language"].isNull())
+				videoStreamsItemObject.language = coverNodeVideoStreamsVideoStreamsItem["Language"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["CodecName"].isNull())
+				videoStreamsItemObject.codecName = coverNodeVideoStreamsVideoStreamsItem["CodecName"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["CodecLongName"].isNull())
+				videoStreamsItemObject.codecLongName = coverNodeVideoStreamsVideoStreamsItem["CodecLongName"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["Profile"].isNull())
+				videoStreamsItemObject.profile = coverNodeVideoStreamsVideoStreamsItem["Profile"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["CodecTimeBase"].isNull())
+				videoStreamsItemObject.codecTimeBase = coverNodeVideoStreamsVideoStreamsItem["CodecTimeBase"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["CodecTagString"].isNull())
+				videoStreamsItemObject.codecTagString = coverNodeVideoStreamsVideoStreamsItem["CodecTagString"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["CodecTag"].isNull())
+				videoStreamsItemObject.codecTag = coverNodeVideoStreamsVideoStreamsItem["CodecTag"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["Width"].isNull())
+				videoStreamsItemObject.width = std::stol(coverNodeVideoStreamsVideoStreamsItem["Width"].asString());
+			if(!coverNodeVideoStreamsVideoStreamsItem["Height"].isNull())
+				videoStreamsItemObject.height = std::stol(coverNodeVideoStreamsVideoStreamsItem["Height"].asString());
+			if(!coverNodeVideoStreamsVideoStreamsItem["HasBFrames"].isNull())
+				videoStreamsItemObject.hasBFrames = std::stol(coverNodeVideoStreamsVideoStreamsItem["HasBFrames"].asString());
+			if(!coverNodeVideoStreamsVideoStreamsItem["SampleAspectRatio"].isNull())
+				videoStreamsItemObject.sampleAspectRatio = coverNodeVideoStreamsVideoStreamsItem["SampleAspectRatio"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["DisplayAspectRatio"].isNull())
+				videoStreamsItemObject.displayAspectRatio = coverNodeVideoStreamsVideoStreamsItem["DisplayAspectRatio"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["PixelFormat"].isNull())
+				videoStreamsItemObject.pixelFormat = coverNodeVideoStreamsVideoStreamsItem["PixelFormat"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["Level"].isNull())
+				videoStreamsItemObject.level = std::stol(coverNodeVideoStreamsVideoStreamsItem["Level"].asString());
+			if(!coverNodeVideoStreamsVideoStreamsItem["FrameRate"].isNull())
+				videoStreamsItemObject.frameRate = coverNodeVideoStreamsVideoStreamsItem["FrameRate"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["AverageFrameRate"].isNull())
+				videoStreamsItemObject.averageFrameRate = coverNodeVideoStreamsVideoStreamsItem["AverageFrameRate"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["TimeBase"].isNull())
+				videoStreamsItemObject.timeBase = coverNodeVideoStreamsVideoStreamsItem["TimeBase"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["StartTime"].isNull())
+				videoStreamsItemObject.startTime = coverNodeVideoStreamsVideoStreamsItem["StartTime"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["Duration"].isNull())
+				videoStreamsItemObject.duration = coverNodeVideoStreamsVideoStreamsItem["Duration"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["Bitrate"].isNull())
+				videoStreamsItemObject.bitrate = std::stol(coverNodeVideoStreamsVideoStreamsItem["Bitrate"].asString());
+			if(!coverNodeVideoStreamsVideoStreamsItem["FrameCount"].isNull())
+				videoStreamsItemObject.frameCount = std::stol(coverNodeVideoStreamsVideoStreamsItem["FrameCount"].asString());
+			if(!coverNodeVideoStreamsVideoStreamsItem["Rotate"].isNull())
+				videoStreamsItemObject.rotate = coverNodeVideoStreamsVideoStreamsItem["Rotate"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["BitDepth"].isNull())
+				videoStreamsItemObject.bitDepth = std::stol(coverNodeVideoStreamsVideoStreamsItem["BitDepth"].asString());
+			if(!coverNodeVideoStreamsVideoStreamsItem["ColorSpace"].isNull())
+				videoStreamsItemObject.colorSpace = coverNodeVideoStreamsVideoStreamsItem["ColorSpace"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["ColorRange"].isNull())
+				videoStreamsItemObject.colorRange = coverNodeVideoStreamsVideoStreamsItem["ColorRange"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["ColorTransfer"].isNull())
+				videoStreamsItemObject.colorTransfer = coverNodeVideoStreamsVideoStreamsItem["ColorTransfer"].asString();
+			if(!coverNodeVideoStreamsVideoStreamsItem["ColorPrimaries"].isNull())
+				videoStreamsItemObject.colorPrimaries = coverNodeVideoStreamsVideoStreamsItem["ColorPrimaries"].asString();
+			figureClustersObject.cover.videoStreams.push_back(videoStreamsItemObject);
+		}
+		auto allSubtitlesNode = coverNode["Subtitles"]["SubtitlesItem"];
+		for (auto coverNodeSubtitlesSubtitlesItem : allSubtitlesNode)
+		{
+			FigureClustersItem::Cover::SubtitlesItem subtitlesItemObject;
+			if(!coverNodeSubtitlesSubtitlesItem["Index"].isNull())
+				subtitlesItemObject.index = std::stol(coverNodeSubtitlesSubtitlesItem["Index"].asString());
+			if(!coverNodeSubtitlesSubtitlesItem["Language"].isNull())
+				subtitlesItemObject.language = coverNodeSubtitlesSubtitlesItem["Language"].asString();
+			if(!coverNodeSubtitlesSubtitlesItem["CodecName"].isNull())
+				subtitlesItemObject.codecName = coverNodeSubtitlesSubtitlesItem["CodecName"].asString();
+			if(!coverNodeSubtitlesSubtitlesItem["CodecLongName"].isNull())
+				subtitlesItemObject.codecLongName = coverNodeSubtitlesSubtitlesItem["CodecLongName"].asString();
+			if(!coverNodeSubtitlesSubtitlesItem["CodecTagString"].isNull())
+				subtitlesItemObject.codecTagString = coverNodeSubtitlesSubtitlesItem["CodecTagString"].asString();
+			if(!coverNodeSubtitlesSubtitlesItem["CodecTag"].isNull())
+				subtitlesItemObject.codecTag = coverNodeSubtitlesSubtitlesItem["CodecTag"].asString();
+			if(!coverNodeSubtitlesSubtitlesItem["StartTime"].isNull())
+				subtitlesItemObject.startTime = coverNodeSubtitlesSubtitlesItem["StartTime"].asString();
+			if(!coverNodeSubtitlesSubtitlesItem["Duration"].isNull())
+				subtitlesItemObject.duration = coverNodeSubtitlesSubtitlesItem["Duration"].asString();
+			if(!coverNodeSubtitlesSubtitlesItem["Bitrate"].isNull())
+				subtitlesItemObject.bitrate = std::stol(coverNodeSubtitlesSubtitlesItem["Bitrate"].asString());
+			if(!coverNodeSubtitlesSubtitlesItem["Content"].isNull())
+				subtitlesItemObject.content = coverNodeSubtitlesSubtitlesItem["Content"].asString();
+			if(!coverNodeSubtitlesSubtitlesItem["Width"].isNull())
+				subtitlesItemObject.width = std::stol(coverNodeSubtitlesSubtitlesItem["Width"].asString());
+			if(!coverNodeSubtitlesSubtitlesItem["Height"].isNull())
+				subtitlesItemObject.height = std::stol(coverNodeSubtitlesSubtitlesItem["Height"].asString());
+			figureClustersObject.cover.subtitles.push_back(subtitlesItemObject);
+		}
+		auto allAudioStreamsNode = coverNode["AudioStreams"]["AudioStreamsItem"];
+		for (auto coverNodeAudioStreamsAudioStreamsItem : allAudioStreamsNode)
+		{
+			FigureClustersItem::Cover::AudioStreamsItem audioStreamsItemObject;
+			if(!coverNodeAudioStreamsAudioStreamsItem["Index"].isNull())
+				audioStreamsItemObject.index = std::stol(coverNodeAudioStreamsAudioStreamsItem["Index"].asString());
+			if(!coverNodeAudioStreamsAudioStreamsItem["Language"].isNull())
+				audioStreamsItemObject.language = coverNodeAudioStreamsAudioStreamsItem["Language"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["CodecName"].isNull())
+				audioStreamsItemObject.codecName = coverNodeAudioStreamsAudioStreamsItem["CodecName"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["CodecLongName"].isNull())
+				audioStreamsItemObject.codecLongName = coverNodeAudioStreamsAudioStreamsItem["CodecLongName"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["CodecTimeBase"].isNull())
+				audioStreamsItemObject.codecTimeBase = coverNodeAudioStreamsAudioStreamsItem["CodecTimeBase"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["CodecTagString"].isNull())
+				audioStreamsItemObject.codecTagString = coverNodeAudioStreamsAudioStreamsItem["CodecTagString"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["CodecTag"].isNull())
+				audioStreamsItemObject.codecTag = coverNodeAudioStreamsAudioStreamsItem["CodecTag"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["TimeBase"].isNull())
+				audioStreamsItemObject.timeBase = coverNodeAudioStreamsAudioStreamsItem["TimeBase"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["StartTime"].isNull())
+				audioStreamsItemObject.startTime = coverNodeAudioStreamsAudioStreamsItem["StartTime"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["Duration"].isNull())
+				audioStreamsItemObject.duration = coverNodeAudioStreamsAudioStreamsItem["Duration"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["Bitrate"].isNull())
+				audioStreamsItemObject.bitrate = std::stol(coverNodeAudioStreamsAudioStreamsItem["Bitrate"].asString());
+			if(!coverNodeAudioStreamsAudioStreamsItem["FrameCount"].isNull())
+				audioStreamsItemObject.frameCount = std::stol(coverNodeAudioStreamsAudioStreamsItem["FrameCount"].asString());
+			if(!coverNodeAudioStreamsAudioStreamsItem["Lyric"].isNull())
+				audioStreamsItemObject.lyric = coverNodeAudioStreamsAudioStreamsItem["Lyric"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["SampleFormat"].isNull())
+				audioStreamsItemObject.sampleFormat = coverNodeAudioStreamsAudioStreamsItem["SampleFormat"].asString();
+			if(!coverNodeAudioStreamsAudioStreamsItem["SampleRate"].isNull())
+				audioStreamsItemObject.sampleRate = std::stol(coverNodeAudioStreamsAudioStreamsItem["SampleRate"].asString());
+			if(!coverNodeAudioStreamsAudioStreamsItem["Channels"].isNull())
+				audioStreamsItemObject.channels = std::stol(coverNodeAudioStreamsAudioStreamsItem["Channels"].asString());
+			if(!coverNodeAudioStreamsAudioStreamsItem["ChannelLayout"].isNull())
+				audioStreamsItemObject.channelLayout = coverNodeAudioStreamsAudioStreamsItem["ChannelLayout"].asString();
+			figureClustersObject.cover.audioStreams.push_back(audioStreamsItemObject);
+		}
+		auto allAudioCoversNode = coverNode["AudioCovers"]["AudioCoversItem"];
+		for (auto coverNodeAudioCoversAudioCoversItem : allAudioCoversNode)
+		{
+			FigureClustersItem::Cover::AudioCoversItem audioCoversItemObject;
+			if(!coverNodeAudioCoversAudioCoversItem["ImageWidth"].isNull())
+				audioCoversItemObject.imageWidth = std::stol(coverNodeAudioCoversAudioCoversItem["ImageWidth"].asString());
+			if(!coverNodeAudioCoversAudioCoversItem["ImageHeight"].isNull())
+				audioCoversItemObject.imageHeight = std::stol(coverNodeAudioCoversAudioCoversItem["ImageHeight"].asString());
+			if(!coverNodeAudioCoversAudioCoversItem["EXIF"].isNull())
+				audioCoversItemObject.eXIF = coverNodeAudioCoversAudioCoversItem["EXIF"].asString();
+			auto allCroppingSuggestions4Node = coverNodeAudioCoversAudioCoversItem["CroppingSuggestions"]["CroppingSuggestionsItem"];
+			for (auto coverNodeAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem : allCroppingSuggestions4Node)
+			{
+				FigureClustersItem::Cover::AudioCoversItem::CroppingSuggestionsItem6 croppingSuggestions4Object;
+				if(!coverNodeAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem["AspectRatio"].isNull())
+					croppingSuggestions4Object.aspectRatio = coverNodeAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem["AspectRatio"].asString();
+				if(!coverNodeAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem["Confidence"].isNull())
+					croppingSuggestions4Object.confidence = std::stof(coverNodeAudioCoversAudioCoversItemCroppingSuggestionsCroppingSuggestionsItem["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());
+				audioCoversItemObject.croppingSuggestions4.push_back(croppingSuggestions4Object);
+			}
+			auto allOCRContents5Node = coverNodeAudioCoversAudioCoversItem["OCRContents"]["OCRContentsItem"];
+			for (auto coverNodeAudioCoversAudioCoversItemOCRContentsOCRContentsItem : allOCRContents5Node)
+			{
+				FigureClustersItem::Cover::AudioCoversItem::OCRContentsItem8 oCRContents5Object;
+				if(!coverNodeAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Language"].isNull())
+					oCRContents5Object.language = coverNodeAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Language"].asString();
+				if(!coverNodeAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Contents"].isNull())
+					oCRContents5Object.contents = coverNodeAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Contents"].asString();
+				if(!coverNodeAudioCoversAudioCoversItemOCRContentsOCRContentsItem["Confidence"].isNull())
+					oCRContents5Object.confidence = std::stof(coverNodeAudioCoversAudioCoversItemOCRContentsOCRContentsItem["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());
+				audioCoversItemObject.oCRContents5.push_back(oCRContents5Object);
+			}
+			auto imageScore3Node = value["ImageScore"];
+			if(!imageScore3Node["OverallQualityScore"].isNull())
+				audioCoversItemObject.imageScore3.overallQualityScore = std::stof(imageScore3Node["OverallQualityScore"].asString());
+			figureClustersObject.cover.audioCovers.push_back(audioCoversItemObject);
+		}
+		auto imageScoreNode = coverNode["ImageScore"];
+		if(!imageScoreNode["OverallQualityScore"].isNull())
+			figureClustersObject.cover.imageScore.overallQualityScore = std::stof(imageScoreNode["OverallQualityScore"].asString());
+		figureClusters_.push_back(figureClustersObject);
+	}
+
+}
+
+std::vector<BatchGetFigureClusterResult::FigureClustersItem> BatchGetFigureClusterResult::getFigureClusters()const
+{
+	return figureClusters_;
+}
+

imm/src/model/BatchGetFileMetaRequest.cc

@@ -25,15 +25,13 @@ BatchGetFileMetaRequest::BatchGetFileMetaRequest()
 
 BatchGetFileMetaRequest::~BatchGetFileMetaRequest() {}
 
-std::vector<BatchGetFileMetaRequest::std::string> BatchGetFileMetaRequest::getURIs() const {
-  return uRIs_;
+std::string BatchGetFileMetaRequest::getDatasetName() const {
+  return datasetName_;
 }
 
-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]);
-  }
+void BatchGetFileMetaRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
 }
 
 std::string BatchGetFileMetaRequest::getProjectName() const {
@@ -45,12 +43,14 @@ void BatchGetFileMetaRequest::setProjectName(const std::string &projectName) {
   setParameter(std::string("ProjectName"), projectName);
 }
 
-std::string BatchGetFileMetaRequest::getDatasetName() const {
-  return datasetName_;
+std::vector<BatchGetFileMetaRequest::std::string> BatchGetFileMetaRequest::getURIs() const {
+  return uRIs_;
 }
 
-void BatchGetFileMetaRequest::setDatasetName(const std::string &datasetName) {
-  datasetName_ = datasetName;
-  setParameter(std::string("DatasetName"), datasetName);
+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/BatchIndexFileMetaRequest.cc

@@ -25,22 +25,17 @@ BatchIndexFileMetaRequest::BatchIndexFileMetaRequest()
 
 BatchIndexFileMetaRequest::~BatchIndexFileMetaRequest() {}
 
-std::string BatchIndexFileMetaRequest::getProjectName() const {
-  return projectName_;
+BatchIndexFileMetaRequest::Notification BatchIndexFileMetaRequest::getNotification() const {
+  return notification_;
 }
 
-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);
+void BatchIndexFileMetaRequest::setNotification(const BatchIndexFileMetaRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
 }
 
 std::string BatchIndexFileMetaRequest::getNotifyEndpoint() const {
@@ -61,6 +56,24 @@ void BatchIndexFileMetaRequest::setDatasetName(const std::string &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_;
 }

imm/src/model/BatchUpdateFileMetaRequest.cc

@@ -25,15 +25,6 @@ BatchUpdateFileMetaRequest::BatchUpdateFileMetaRequest()
 
 BatchUpdateFileMetaRequest::~BatchUpdateFileMetaRequest() {}
 
-std::string BatchUpdateFileMetaRequest::getProjectName() const {
-  return projectName_;
-}
-
-void BatchUpdateFileMetaRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
 std::string BatchUpdateFileMetaRequest::getDatasetName() const {
   return datasetName_;
 }
@@ -43,6 +34,15 @@ void BatchUpdateFileMetaRequest::setDatasetName(const std::string &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_;
 }

imm/src/model/CompareImageFacesRequest.cc

@@ -19,72 +19,43 @@
 using AlibabaCloud::Imm::Model::CompareImageFacesRequest;
 
 CompareImageFacesRequest::CompareImageFacesRequest()
-    : RpcServiceRequest("imm", "2017-09-06", "CompareImageFaces") {
+    : RpcServiceRequest("imm", "2020-09-30", "CompareImageFaces") {
   setMethod(HttpRequest::Method::Post);
 }
 
 CompareImageFacesRequest::~CompareImageFacesRequest() {}
 
-std::string CompareImageFacesRequest::getProject() const {
-  return project_;
+CompareImageFacesRequest::Source CompareImageFacesRequest::getSource() const {
+  return source_;
 }
 
-void CompareImageFacesRequest::setProject(const std::string &project) {
-  project_ = project;
-  setParameter(std::string("Project"), project);
+void CompareImageFacesRequest::setSource(const CompareImageFacesRequest::Source &source) {
+  source_ = source;
+  setParameter(std::string("Source") + ".URI2", source.uRI2);
+  setParameter(std::string("Source") + ".URI1", source.uRI1);
 }
 
-std::string CompareImageFacesRequest::getFaceIdA() const {
-  return faceIdA_;
+std::string CompareImageFacesRequest::getProjectName() const {
+  return projectName_;
 }
 
-void CompareImageFacesRequest::setFaceIdA(const std::string &faceIdA) {
-  faceIdA_ = faceIdA;
-  setParameter(std::string("FaceIdA"), faceIdA);
+void CompareImageFacesRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
 }
 
-std::string CompareImageFacesRequest::getFaceIdB() const {
-  return faceIdB_;
+CompareImageFacesRequest::CredentialConfig CompareImageFacesRequest::getCredentialConfig() const {
+  return credentialConfig_;
 }
 
-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);
+void CompareImageFacesRequest::setCredentialConfig(const CompareImageFacesRequest::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/CompareImageFacesResult.cc

@@ -39,36 +39,8 @@ void CompareImageFacesResult::parse(const std::string &payload)
 	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();
 
 }
 
@@ -77,18 +49,3 @@ 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/CreateArchiveFileInspectionTaskRequest.cc

@@ -0,0 +1,118 @@
+/*
+ * 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/CreateArchiveFileInspectionTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateArchiveFileInspectionTaskRequest;
+
+CreateArchiveFileInspectionTaskRequest::CreateArchiveFileInspectionTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateArchiveFileInspectionTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateArchiveFileInspectionTaskRequest::~CreateArchiveFileInspectionTaskRequest() {}
+
+std::string CreateArchiveFileInspectionTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateArchiveFileInspectionTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+CreateArchiveFileInspectionTaskRequest::Notification CreateArchiveFileInspectionTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateArchiveFileInspectionTaskRequest::setNotification(const CreateArchiveFileInspectionTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+std::string CreateArchiveFileInspectionTaskRequest::getPassword() const {
+  return password_;
+}
+
+void CreateArchiveFileInspectionTaskRequest::setPassword(const std::string &password) {
+  password_ = password;
+  setParameter(std::string("Password"), password);
+}
+
+std::string CreateArchiveFileInspectionTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateArchiveFileInspectionTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateArchiveFileInspectionTaskRequest::getTargetURI() const {
+  return targetURI_;
+}
+
+void CreateArchiveFileInspectionTaskRequest::setTargetURI(const std::string &targetURI) {
+  targetURI_ = targetURI;
+  setParameter(std::string("TargetURI"), targetURI);
+}
+
+std::string CreateArchiveFileInspectionTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateArchiveFileInspectionTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateArchiveFileInspectionTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateArchiveFileInspectionTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+CreateArchiveFileInspectionTaskRequest::CredentialConfig CreateArchiveFileInspectionTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateArchiveFileInspectionTaskRequest::setCredentialConfig(const CreateArchiveFileInspectionTaskRequest::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 CreateArchiveFileInspectionTaskRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void CreateArchiveFileInspectionTaskRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/CreateArchiveFileInspectionTaskResult.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/CreateArchiveFileInspectionTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateArchiveFileInspectionTaskResult::CreateArchiveFileInspectionTaskResult() :
+	ServiceResult()
+{}
+
+CreateArchiveFileInspectionTaskResult::CreateArchiveFileInspectionTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateArchiveFileInspectionTaskResult::~CreateArchiveFileInspectionTaskResult()
+{}
+
+void CreateArchiveFileInspectionTaskResult::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();
+
+}
+
+std::string CreateArchiveFileInspectionTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string CreateArchiveFileInspectionTaskResult::getEventId()const
+{
+	return eventId_;
+}
+

imm/src/model/CreateBatchRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * 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/CreateBatchRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateBatchRequest;
+
+CreateBatchRequest::CreateBatchRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateBatch") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateBatchRequest::~CreateBatchRequest() {}
+
+CreateBatchRequest::Notification CreateBatchRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateBatchRequest::setNotification(const CreateBatchRequest::Notification &notification) {
+  notification_ = notification;
+  setBodyParameter(std::string("Notification") + ".Endpoint", notification.endpoint);
+  setBodyParameter(std::string("Notification") + ".Topic", notification.topic);
+}
+
+std::string CreateBatchRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateBatchRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setBodyParameter(std::string("ProjectName"), projectName);
+}
+
+std::map<std::string, std::string> CreateBatchRequest::getTags() const {
+  return tags_;
+}
+
+void CreateBatchRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setBodyParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+
+CreateBatchRequest::Input CreateBatchRequest::getInput() const {
+  return input_;
+}
+
+void CreateBatchRequest::setInput(const CreateBatchRequest::Input &input) {
+  input_ = input;
+  setBodyParameter(std::string("Input") + ".OSS.Bucket", input.oSS.bucket);
+  setBodyParameter(std::string("Input") + ".OSS.Prefix", input.oSS.prefix);
+  for(int dep1 = 0; dep1 != input.oSS.matchExpressions.size(); dep1++) {
+    setBodyParameter(std::string("Input") + ".OSS.MatchExpressions." + std::to_string(dep1 + 1), input.oSS.matchExpressions[dep1]);
+  }
+}
+
+std::string CreateBatchRequest::getServiceRole() const {
+  return serviceRole_;
+}
+
+void CreateBatchRequest::setServiceRole(const std::string &serviceRole) {
+  serviceRole_ = serviceRole;
+  setBodyParameter(std::string("ServiceRole"), serviceRole);
+}
+
+std::vector<CreateBatchRequest::Actions> CreateBatchRequest::getActions() const {
+  return actions_;
+}
+
+void CreateBatchRequest::setActions(const std::vector<CreateBatchRequest::Actions> &actions) {
+  actions_ = actions;
+  for(int dep1 = 0; dep1 != actions.size(); dep1++) {
+    setBodyParameter(std::string("Actions") + "." + std::to_string(dep1 + 1) + ".Name", actions[dep1].name);
+    for(int dep2 = 0; dep2 != actions[dep1].parameters.size(); dep2++) {
+      setBodyParameter(std::string("Actions") + "." + std::to_string(dep1 + 1) + ".Parameters." + std::to_string(dep2 + 1), actions[dep1].parameters[dep2]);
+    }
+  }
+}
+

imm/src/model/CreateBatchResult.cc

@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/OpenImmServiceResult.h>
+#include <alibabacloud/imm/model/CreateBatchResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-OpenImmServiceResult::OpenImmServiceResult() :
+CreateBatchResult::CreateBatchResult() :
 	ServiceResult()
 {}
 
-OpenImmServiceResult::OpenImmServiceResult(const std::string &payload) :
+CreateBatchResult::CreateBatchResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-OpenImmServiceResult::~OpenImmServiceResult()
+CreateBatchResult::~CreateBatchResult()
 {}
 
-void OpenImmServiceResult::parse(const std::string &payload)
+void CreateBatchResult::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["Id"].isNull())
+		id_ = value["Id"].asString();
 
 }
 
-std::string OpenImmServiceResult::getOrderId()const
+std::string CreateBatchResult::getId()const
 {
-	return orderId_;
+	return id_;
 }
 

imm/src/model/CreateBindingRequest.cc

@@ -25,15 +25,6 @@ CreateBindingRequest::CreateBindingRequest()
 
 CreateBindingRequest::~CreateBindingRequest() {}
 
-std::string CreateBindingRequest::getProjectName() const {
-  return projectName_;
-}
-
-void CreateBindingRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
 std::string CreateBindingRequest::getBucketOwnerId() const {
   return bucketOwnerId_;
 }
@@ -52,6 +43,15 @@ void CreateBindingRequest::setDatasetName(const std::string &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_;
 }

imm/src/model/CreateCompressPointCloudTaskRequest.cc

@@ -0,0 +1,172 @@
+/*
+ * 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/CreateCompressPointCloudTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateCompressPointCloudTaskRequest;
+
+CreateCompressPointCloudTaskRequest::CreateCompressPointCloudTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateCompressPointCloudTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateCompressPointCloudTaskRequest::~CreateCompressPointCloudTaskRequest() {}
+
+CreateCompressPointCloudTaskRequest::Notification CreateCompressPointCloudTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateCompressPointCloudTaskRequest::setNotification(const CreateCompressPointCloudTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+std::string CreateCompressPointCloudTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateCompressPointCloudTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateCompressPointCloudTaskRequest::getCompressMethod() const {
+  return compressMethod_;
+}
+
+void CreateCompressPointCloudTaskRequest::setCompressMethod(const std::string &compressMethod) {
+  compressMethod_ = compressMethod;
+  setParameter(std::string("CompressMethod"), compressMethod);
+}
+
+std::string CreateCompressPointCloudTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateCompressPointCloudTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateCompressPointCloudTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateCompressPointCloudTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+std::map<std::string, std::string> CreateCompressPointCloudTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateCompressPointCloudTaskRequest::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<CreateCompressPointCloudTaskRequest::std::string> CreateCompressPointCloudTaskRequest::getPointCloudFields() const {
+  return pointCloudFields_;
+}
+
+void CreateCompressPointCloudTaskRequest::setPointCloudFields(const std::vector<CreateCompressPointCloudTaskRequest::std::string> &pointCloudFields) {
+  pointCloudFields_ = pointCloudFields;
+  for(int dep1 = 0; dep1 != pointCloudFields.size(); dep1++) {
+    setParameter(std::string("PointCloudFields") + "." + std::to_string(dep1 + 1), pointCloudFields[dep1]);
+  }
+}
+
+std::string CreateCompressPointCloudTaskRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void CreateCompressPointCloudTaskRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+
+std::string CreateCompressPointCloudTaskRequest::getPointCloudFileFormat() const {
+  return pointCloudFileFormat_;
+}
+
+void CreateCompressPointCloudTaskRequest::setPointCloudFileFormat(const std::string &pointCloudFileFormat) {
+  pointCloudFileFormat_ = pointCloudFileFormat;
+  setParameter(std::string("PointCloudFileFormat"), pointCloudFileFormat);
+}
+
+CreateCompressPointCloudTaskRequest::OctreeOption CreateCompressPointCloudTaskRequest::getOctreeOption() const {
+  return octreeOption_;
+}
+
+void CreateCompressPointCloudTaskRequest::setOctreeOption(const CreateCompressPointCloudTaskRequest::OctreeOption &octreeOption) {
+  octreeOption_ = octreeOption;
+  setParameter(std::string("OctreeOption") + ".PointResolution", std::to_string(octreeOption.pointResolution));
+  setParameter(std::string("OctreeOption") + ".LibraryName", octreeOption.libraryName);
+  setParameter(std::string("OctreeOption") + ".DoVoxelGridDownDownSampling", octreeOption.doVoxelGridDownDownSampling ? "true" : "false");
+  setParameter(std::string("OctreeOption") + ".OctreeResolution", std::to_string(octreeOption.octreeResolution));
+}
+
+std::string CreateCompressPointCloudTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateCompressPointCloudTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+std::string CreateCompressPointCloudTaskRequest::getTargetURI() const {
+  return targetURI_;
+}
+
+void CreateCompressPointCloudTaskRequest::setTargetURI(const std::string &targetURI) {
+  targetURI_ = targetURI;
+  setParameter(std::string("TargetURI"), targetURI);
+}
+
+CreateCompressPointCloudTaskRequest::KdtreeOption CreateCompressPointCloudTaskRequest::getKdtreeOption() const {
+  return kdtreeOption_;
+}
+
+void CreateCompressPointCloudTaskRequest::setKdtreeOption(const CreateCompressPointCloudTaskRequest::KdtreeOption &kdtreeOption) {
+  kdtreeOption_ = kdtreeOption;
+  setParameter(std::string("KdtreeOption") + ".QuantizationBits", std::to_string(kdtreeOption.quantizationBits));
+  setParameter(std::string("KdtreeOption") + ".LibraryName", kdtreeOption.libraryName);
+  setParameter(std::string("KdtreeOption") + ".CompressionLevel", std::to_string(kdtreeOption.compressionLevel));
+}
+
+CreateCompressPointCloudTaskRequest::CredentialConfig CreateCompressPointCloudTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateCompressPointCloudTaskRequest::setCredentialConfig(const CreateCompressPointCloudTaskRequest::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/CreateCompressPointCloudTaskResult.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/CreateCompressPointCloudTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateCompressPointCloudTaskResult::CreateCompressPointCloudTaskResult() :
+	ServiceResult()
+{}
+
+CreateCompressPointCloudTaskResult::CreateCompressPointCloudTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateCompressPointCloudTaskResult::~CreateCompressPointCloudTaskResult()
+{}
+
+void CreateCompressPointCloudTaskResult::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 CreateCompressPointCloudTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string CreateCompressPointCloudTaskResult::getEventId()const
+{
+	return eventId_;
+}
+

imm/src/model/CreateCustomizedStoryRequest.cc

@@ -0,0 +1,103 @@
+/*
+ * 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/CreateCustomizedStoryRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateCustomizedStoryRequest;
+
+CreateCustomizedStoryRequest::CreateCustomizedStoryRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateCustomizedStory") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateCustomizedStoryRequest::~CreateCustomizedStoryRequest() {}
+
+std::map<std::string, std::string> CreateCustomizedStoryRequest::getCustomLabels() const {
+  return customLabels_;
+}
+
+void CreateCustomizedStoryRequest::setCustomLabels(const std::map<std::string, std::string> &customLabels) {
+  customLabels_ = customLabels;
+  for(auto const &iter1 : customLabels) {
+    setBodyParameter(std::string("CustomLabels") + "." + iter1.first, iter1.second);
+  }
+}
+
+CreateCustomizedStoryRequest::Cover CreateCustomizedStoryRequest::getCover() const {
+  return cover_;
+}
+
+void CreateCustomizedStoryRequest::setCover(const CreateCustomizedStoryRequest::Cover &cover) {
+  cover_ = cover;
+  setBodyParameter(std::string("Cover") + ".URI", cover.uRI);
+}
+
+std::string CreateCustomizedStoryRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void CreateCustomizedStoryRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setBodyParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string CreateCustomizedStoryRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateCustomizedStoryRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setBodyParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateCustomizedStoryRequest::getStoryType() const {
+  return storyType_;
+}
+
+void CreateCustomizedStoryRequest::setStoryType(const std::string &storyType) {
+  storyType_ = storyType;
+  setBodyParameter(std::string("StoryType"), storyType);
+}
+
+std::string CreateCustomizedStoryRequest::getStorySubType() const {
+  return storySubType_;
+}
+
+void CreateCustomizedStoryRequest::setStorySubType(const std::string &storySubType) {
+  storySubType_ = storySubType;
+  setBodyParameter(std::string("StorySubType"), storySubType);
+}
+
+std::vector<CreateCustomizedStoryRequest::Files> CreateCustomizedStoryRequest::getFiles() const {
+  return files_;
+}
+
+void CreateCustomizedStoryRequest::setFiles(const std::vector<CreateCustomizedStoryRequest::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 CreateCustomizedStoryRequest::getStoryName() const {
+  return storyName_;
+}
+
+void CreateCustomizedStoryRequest::setStoryName(const std::string &storyName) {
+  storyName_ = storyName;
+  setBodyParameter(std::string("StoryName"), storyName);
+}
+

imm/src/model/CreateCustomizedStoryResult.cc

@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/ConvertOfficeFormatResult.h>
+#include <alibabacloud/imm/model/CreateCustomizedStoryResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-ConvertOfficeFormatResult::ConvertOfficeFormatResult() :
+CreateCustomizedStoryResult::CreateCustomizedStoryResult() :
 	ServiceResult()
 {}
 
-ConvertOfficeFormatResult::ConvertOfficeFormatResult(const std::string &payload) :
+CreateCustomizedStoryResult::CreateCustomizedStoryResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-ConvertOfficeFormatResult::~ConvertOfficeFormatResult()
+CreateCustomizedStoryResult::~CreateCustomizedStoryResult()
 {}
 
-void ConvertOfficeFormatResult::parse(const std::string &payload)
+void CreateCustomizedStoryResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["PageCount"].isNull())
-		pageCount_ = std::stoi(value["PageCount"].asString());
+	if(!value["ObjectId"].isNull())
+		objectId_ = value["ObjectId"].asString();
 
 }
 
-int ConvertOfficeFormatResult::getPageCount()const
+std::string CreateCustomizedStoryResult::getObjectId()const
 {
-	return pageCount_;
+	return objectId_;
 }
 

imm/src/model/CreateDatasetRequest.cc

@@ -25,15 +25,6 @@ CreateDatasetRequest::CreateDatasetRequest()
 
 CreateDatasetRequest::~CreateDatasetRequest() {}
 
-std::string CreateDatasetRequest::getProjectName() const {
-  return projectName_;
-}
-
-void CreateDatasetRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
 long CreateDatasetRequest::getDatasetMaxBindCount() const {
   return datasetMaxBindCount_;
 }
@@ -43,13 +34,13 @@ void CreateDatasetRequest::setDatasetMaxBindCount(long datasetMaxBindCount) {
   setParameter(std::string("DatasetMaxBindCount"), std::to_string(datasetMaxBindCount));
 }
 
-long CreateDatasetRequest::getDatasetMaxTotalFileSize() const {
-  return datasetMaxTotalFileSize_;
+std::string CreateDatasetRequest::getDescription() const {
+  return description_;
 }
 
-void CreateDatasetRequest::setDatasetMaxTotalFileSize(long datasetMaxTotalFileSize) {
-  datasetMaxTotalFileSize_ = datasetMaxTotalFileSize;
-  setParameter(std::string("DatasetMaxTotalFileSize"), std::to_string(datasetMaxTotalFileSize));
+void CreateDatasetRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
 long CreateDatasetRequest::getDatasetMaxRelationCount() const {
@@ -70,13 +61,22 @@ void CreateDatasetRequest::setDatasetName(const std::string &datasetName) {
   setParameter(std::string("DatasetName"), datasetName);
 }
 
-std::string CreateDatasetRequest::getDescription() const {
-  return description_;
+long CreateDatasetRequest::getDatasetMaxFileCount() const {
+  return datasetMaxFileCount_;
 }
 
-void CreateDatasetRequest::setDescription(const std::string &description) {
-  description_ = description;
-  setParameter(std::string("Description"), description);
+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 {
@@ -88,15 +88,6 @@ void CreateDatasetRequest::setDatasetMaxEntityCount(long datasetMaxEntityCount)
   setParameter(std::string("DatasetMaxEntityCount"), std::to_string(datasetMaxEntityCount));
 }
 
-long CreateDatasetRequest::getDatasetMaxFileCount() const {
-  return datasetMaxFileCount_;
-}
-
-void CreateDatasetRequest::setDatasetMaxFileCount(long datasetMaxFileCount) {
-  datasetMaxFileCount_ = datasetMaxFileCount;
-  setParameter(std::string("DatasetMaxFileCount"), std::to_string(datasetMaxFileCount));
-}
-
 std::string CreateDatasetRequest::getTemplateId() const {
   return templateId_;
 }
@@ -106,3 +97,12 @@ void CreateDatasetRequest::setTemplateId(const std::string &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/CreateDetectVideoLabelsTaskRequest.cc

@@ -1,98 +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/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::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);
-}
-
-std::string CreateDetectVideoLabelsTaskRequest::getSourceURI() const {
-  return sourceURI_;
-}
-
-void CreateDetectVideoLabelsTaskRequest::setSourceURI(const std::string &sourceURI) {
-  sourceURI_ = sourceURI;
-  setParameter(std::string("SourceURI"), sourceURI);
-}
-
-std::string CreateDetectVideoLabelsTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateDetectVideoLabelsTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-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);
-  }
-}
-

imm/src/model/CreateFacesSearchingTaskRequest.cc

@@ -0,0 +1,105 @@
+/*
+ * 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/CreateFacesSearchingTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateFacesSearchingTaskRequest;
+
+CreateFacesSearchingTaskRequest::CreateFacesSearchingTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateFacesSearchingTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateFacesSearchingTaskRequest::~CreateFacesSearchingTaskRequest() {}
+
+long CreateFacesSearchingTaskRequest::getTopK() const {
+  return topK_;
+}
+
+void CreateFacesSearchingTaskRequest::setTopK(long topK) {
+  topK_ = topK;
+  setParameter(std::string("TopK"), std::to_string(topK));
+}
+
+std::vector<CreateFacesSearchingTaskRequest::Sources> CreateFacesSearchingTaskRequest::getSources() const {
+  return sources_;
+}
+
+void CreateFacesSearchingTaskRequest::setSources(const std::vector<CreateFacesSearchingTaskRequest::Sources> &sources) {
+  sources_ = sources;
+  for(int dep1 = 0; dep1 != sources.size(); dep1++) {
+    setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".URI", sources[dep1].uRI);
+  }
+}
+
+std::string CreateFacesSearchingTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateFacesSearchingTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+CreateFacesSearchingTaskRequest::Notification CreateFacesSearchingTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateFacesSearchingTaskRequest::setNotification(const CreateFacesSearchingTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+std::string CreateFacesSearchingTaskRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void CreateFacesSearchingTaskRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string CreateFacesSearchingTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateFacesSearchingTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateFacesSearchingTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateFacesSearchingTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+std::string CreateFacesSearchingTaskRequest::getMaxResult() const {
+  return maxResult_;
+}
+
+void CreateFacesSearchingTaskRequest::setMaxResult(const std::string &maxResult) {
+  maxResult_ = maxResult;
+  setParameter(std::string("MaxResult"), maxResult);
+}
+

imm/src/model/CreateFacesSearchingTaskResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateVideoCompressTaskResult.h>
+#include <alibabacloud/imm/model/CreateFacesSearchingTaskResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateVideoCompressTaskResult::CreateVideoCompressTaskResult() :
+CreateFacesSearchingTaskResult::CreateFacesSearchingTaskResult() :
 	ServiceResult()
 {}
 
-CreateVideoCompressTaskResult::CreateVideoCompressTaskResult(const std::string &payload) :
+CreateFacesSearchingTaskResult::CreateFacesSearchingTaskResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateVideoCompressTaskResult::~CreateVideoCompressTaskResult()
+CreateFacesSearchingTaskResult::~CreateFacesSearchingTaskResult()
 {}
 
-void CreateVideoCompressTaskResult::parse(const std::string &payload)
+void CreateFacesSearchingTaskResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
@@ -41,18 +41,18 @@ void CreateVideoCompressTaskResult::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 CreateVideoCompressTaskResult::getTaskId()const
+std::string CreateFacesSearchingTaskResult::getTaskId()const
 {
 	return taskId_;
 }
 
-std::string CreateVideoCompressTaskResult::getTaskType()const
+std::string CreateFacesSearchingTaskResult::getEventId()const
 {
-	return taskType_;
+	return eventId_;
 }
 

imm/src/model/CreateFigureClusteringTaskRequest.cc

@@ -34,22 +34,17 @@ void CreateFigureClusteringTaskRequest::setUserData(const std::string &userData)
   setParameter(std::string("UserData"), userData);
 }
 
-std::string CreateFigureClusteringTaskRequest::getProjectName() const {
-  return projectName_;
+CreateFigureClusteringTaskRequest::Notification CreateFigureClusteringTaskRequest::getNotification() const {
+  return notification_;
 }
 
-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);
+void CreateFigureClusteringTaskRequest::setNotification(const CreateFigureClusteringTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
 }
 
 std::string CreateFigureClusteringTaskRequest::getNotifyEndpoint() const {
@@ -70,6 +65,24 @@ void CreateFigureClusteringTaskRequest::setDatasetName(const std::string &datase
   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_;
 }

imm/src/model/CreateFigureClustersMergingTaskRequest.cc

@@ -34,22 +34,17 @@ void CreateFigureClustersMergingTaskRequest::setUserData(const std::string &user
   setParameter(std::string("UserData"), userData);
 }
 
-std::string CreateFigureClustersMergingTaskRequest::getProjectName() const {
-  return projectName_;
+CreateFigureClustersMergingTaskRequest::Notification CreateFigureClustersMergingTaskRequest::getNotification() const {
+  return notification_;
 }
 
-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);
+void CreateFigureClustersMergingTaskRequest::setNotification(const CreateFigureClustersMergingTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
 }
 
 std::string CreateFigureClustersMergingTaskRequest::getNotifyEndpoint() const {
@@ -79,13 +74,33 @@ void CreateFigureClustersMergingTaskRequest::setFrom(const std::string &from) {
   setParameter(std::string("From"), from);
 }
 
-std::string CreateFigureClustersMergingTaskRequest::getTo() const {
-  return to_;
+std::vector<CreateFigureClustersMergingTaskRequest::std::string> CreateFigureClustersMergingTaskRequest::getFroms() const {
+  return froms_;
 }
 
-void CreateFigureClustersMergingTaskRequest::setTo(const std::string &to) {
-  to_ = to;
-  setParameter(std::string("To"), to);
+void CreateFigureClustersMergingTaskRequest::setFroms(const std::vector<CreateFigureClustersMergingTaskRequest::std::string> &froms) {
+  froms_ = froms;
+  for(int dep1 = 0; dep1 != froms.size(); dep1++) {
+    setParameter(std::string("Froms") + "." + std::to_string(dep1 + 1), froms[dep1]);
+  }
+}
+
+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 {
@@ -99,3 +114,12 @@ void CreateFigureClustersMergingTaskRequest::setTags(const std::map<std::string,
   }
 }
 
+std::string CreateFigureClustersMergingTaskRequest::getTo() const {
+  return to_;
+}
+
+void CreateFigureClustersMergingTaskRequest::setTo(const std::string &to) {
+  to_ = to;
+  setParameter(std::string("To"), to);
+}
+

imm/src/model/CreateFileCompressionTaskRequest.cc

@@ -0,0 +1,148 @@
+/*
+ * 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/CreateFileCompressionTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateFileCompressionTaskRequest;
+
+CreateFileCompressionTaskRequest::CreateFileCompressionTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateFileCompressionTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateFileCompressionTaskRequest::~CreateFileCompressionTaskRequest() {}
+
+std::vector<CreateFileCompressionTaskRequest::Sources> CreateFileCompressionTaskRequest::getSources() const {
+  return sources_;
+}
+
+void CreateFileCompressionTaskRequest::setSources(const std::vector<CreateFileCompressionTaskRequest::Sources> &sources) {
+  sources_ = sources;
+  for(int dep1 = 0; dep1 != sources.size(); dep1++) {
+    setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".Alias", sources[dep1].alias);
+    setParameter(std::string("Sources") + "." + std::to_string(dep1 + 1) + ".URI", sources[dep1].uRI);
+  }
+}
+
+std::string CreateFileCompressionTaskRequest::getSourceManifestURI() const {
+  return sourceManifestURI_;
+}
+
+void CreateFileCompressionTaskRequest::setSourceManifestURI(const std::string &sourceManifestURI) {
+  sourceManifestURI_ = sourceManifestURI;
+  setParameter(std::string("SourceManifestURI"), sourceManifestURI);
+}
+
+std::string CreateFileCompressionTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateFileCompressionTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+CreateFileCompressionTaskRequest::Notification CreateFileCompressionTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateFileCompressionTaskRequest::setNotification(const CreateFileCompressionTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+std::string CreateFileCompressionTaskRequest::getPassword() const {
+  return password_;
+}
+
+void CreateFileCompressionTaskRequest::setPassword(const std::string &password) {
+  password_ = password;
+  setParameter(std::string("Password"), password);
+}
+
+std::string CreateFileCompressionTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateFileCompressionTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateFileCompressionTaskRequest::getTargetURI() const {
+  return targetURI_;
+}
+
+void CreateFileCompressionTaskRequest::setTargetURI(const std::string &targetURI) {
+  targetURI_ = targetURI;
+  setParameter(std::string("TargetURI"), targetURI);
+}
+
+std::string CreateFileCompressionTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateFileCompressionTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateFileCompressionTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateFileCompressionTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+CreateFileCompressionTaskRequest::CredentialConfig CreateFileCompressionTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateFileCompressionTaskRequest::setCredentialConfig(const CreateFileCompressionTaskRequest::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);
+}
+
+bool CreateFileCompressionTaskRequest::getAllowCrossRegion() const {
+  return allowCrossRegion_;
+}
+
+void CreateFileCompressionTaskRequest::setAllowCrossRegion(bool allowCrossRegion) {
+  allowCrossRegion_ = allowCrossRegion;
+  setParameter(std::string("AllowCrossRegion"), allowCrossRegion ? "true" : "false");
+}
+
+std::string CreateFileCompressionTaskRequest::getCompressedFormat() const {
+  return compressedFormat_;
+}
+
+void CreateFileCompressionTaskRequest::setCompressedFormat(const std::string &compressedFormat) {
+  compressedFormat_ = compressedFormat;
+  setParameter(std::string("CompressedFormat"), compressedFormat);
+}
+

imm/src/model/CreateFileCompressionTaskResult.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/CreateFileCompressionTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateFileCompressionTaskResult::CreateFileCompressionTaskResult() :
+	ServiceResult()
+{}
+
+CreateFileCompressionTaskResult::CreateFileCompressionTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateFileCompressionTaskResult::~CreateFileCompressionTaskResult()
+{}
+
+void CreateFileCompressionTaskResult::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();
+
+}
+
+std::string CreateFileCompressionTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string CreateFileCompressionTaskResult::getEventId()const
+{
+	return eventId_;
+}
+

imm/src/model/CreateFileUncompressionTaskRequest.cc

@@ -0,0 +1,130 @@
+/*
+ * 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/CreateFileUncompressionTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateFileUncompressionTaskRequest;
+
+CreateFileUncompressionTaskRequest::CreateFileUncompressionTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateFileUncompressionTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateFileUncompressionTaskRequest::~CreateFileUncompressionTaskRequest() {}
+
+std::string CreateFileUncompressionTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateFileUncompressionTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+CreateFileUncompressionTaskRequest::Notification CreateFileUncompressionTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateFileUncompressionTaskRequest::setNotification(const CreateFileUncompressionTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+std::string CreateFileUncompressionTaskRequest::getPassword() const {
+  return password_;
+}
+
+void CreateFileUncompressionTaskRequest::setPassword(const std::string &password) {
+  password_ = password;
+  setParameter(std::string("Password"), password);
+}
+
+std::vector<CreateFileUncompressionTaskRequest::std::string> CreateFileUncompressionTaskRequest::getSelectedFiles() const {
+  return selectedFiles_;
+}
+
+void CreateFileUncompressionTaskRequest::setSelectedFiles(const std::vector<CreateFileUncompressionTaskRequest::std::string> &selectedFiles) {
+  selectedFiles_ = selectedFiles;
+  for(int dep1 = 0; dep1 != selectedFiles.size(); dep1++) {
+    setParameter(std::string("SelectedFiles") + "." + std::to_string(dep1 + 1), selectedFiles[dep1]);
+  }
+}
+
+std::string CreateFileUncompressionTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateFileUncompressionTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateFileUncompressionTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateFileUncompressionTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateFileUncompressionTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateFileUncompressionTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+CreateFileUncompressionTaskRequest::CredentialConfig CreateFileUncompressionTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateFileUncompressionTaskRequest::setCredentialConfig(const CreateFileUncompressionTaskRequest::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);
+}
+
+CreateFileUncompressionTaskRequest::Target CreateFileUncompressionTaskRequest::getTarget() const {
+  return target_;
+}
+
+void CreateFileUncompressionTaskRequest::setTarget(const CreateFileUncompressionTaskRequest::Target &target) {
+  target_ = target;
+  setParameter(std::string("Target") + ".ManifestURI", target.manifestURI);
+  setParameter(std::string("Target") + ".URI", target.uRI);
+}
+
+std::string CreateFileUncompressionTaskRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void CreateFileUncompressionTaskRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/CreateFileUncompressionTaskResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateDetectVideoLabelsTaskResult.h>
+#include <alibabacloud/imm/model/CreateFileUncompressionTaskResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateDetectVideoLabelsTaskResult::CreateDetectVideoLabelsTaskResult() :
+CreateFileUncompressionTaskResult::CreateFileUncompressionTaskResult() :
 	ServiceResult()
 {}
 
-CreateDetectVideoLabelsTaskResult::CreateDetectVideoLabelsTaskResult(const std::string &payload) :
+CreateFileUncompressionTaskResult::CreateFileUncompressionTaskResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateDetectVideoLabelsTaskResult::~CreateDetectVideoLabelsTaskResult()
+CreateFileUncompressionTaskResult::~CreateFileUncompressionTaskResult()
 {}
 
-void CreateDetectVideoLabelsTaskResult::parse(const std::string &payload)
+void CreateFileUncompressionTaskResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
@@ -46,12 +46,12 @@ void CreateDetectVideoLabelsTaskResult::parse(const std::string &payload)
 
 }
 
-std::string CreateDetectVideoLabelsTaskResult::getTaskId()const
+std::string CreateFileUncompressionTaskResult::getTaskId()const
 {
 	return taskId_;
 }
 
-std::string CreateDetectVideoLabelsTaskResult::getEventId()const
+std::string CreateFileUncompressionTaskResult::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

@@ -34,6 +34,28 @@ void CreateImageModerationTaskRequest::setUserData(const std::string &userData)
   setParameter(std::string("UserData"), userData);
 }
 
+CreateImageModerationTaskRequest::Notification CreateImageModerationTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateImageModerationTaskRequest::setNotification(const CreateImageModerationTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+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_;
 }
@@ -52,35 +74,6 @@ void CreateImageModerationTaskRequest::setNotifyTopicName(const std::string &not
   setParameter(std::string("NotifyTopicName"), notifyTopicName);
 }
 
-std::string CreateImageModerationTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateImageModerationTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-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::getMaxFrames() const {
   return maxFrames_;
 }
@@ -90,15 +83,6 @@ void CreateImageModerationTaskRequest::setMaxFrames(long maxFrames) {
   setParameter(std::string("MaxFrames"), std::to_string(maxFrames));
 }
 
-long CreateImageModerationTaskRequest::getInterval() const {
-  return interval_;
-}
-
-void CreateImageModerationTaskRequest::setInterval(long interval) {
-  interval_ = interval;
-  setParameter(std::string("Interval"), std::to_string(interval));
-}
-
 CreateImageModerationTaskRequest::CredentialConfig CreateImageModerationTaskRequest::getCredentialConfig() const {
   return credentialConfig_;
 }
@@ -134,3 +118,32 @@ void CreateImageModerationTaskRequest::setTags(const std::map<std::string, std::
   }
 }
 
+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/CreateImageSplicingTaskRequest.cc

@@ -25,13 +25,53 @@ CreateImageSplicingTaskRequest::CreateImageSplicingTaskRequest()
 
 CreateImageSplicingTaskRequest::~CreateImageSplicingTaskRequest() {}
 
-long CreateImageSplicingTaskRequest::getPadding() const {
-  return padding_;
+long CreateImageSplicingTaskRequest::getAlign() const {
+  return align_;
 }
 
-void CreateImageSplicingTaskRequest::setPadding(long padding) {
-  padding_ = padding;
-  setParameter(std::string("Padding"), std::to_string(padding));
+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);
+}
+
+CreateImageSplicingTaskRequest::Notification CreateImageSplicingTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateImageSplicingTaskRequest::setNotification(const CreateImageSplicingTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+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 {
@@ -61,42 +101,6 @@ void CreateImageSplicingTaskRequest::setNotifyTopicName(const std::string &notif
   setParameter(std::string("NotifyTopicName"), notifyTopicName);
 }
 
-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);
-  }
-}
-
-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);
-}
-
-long CreateImageSplicingTaskRequest::getAlign() const {
-  return align_;
-}
-
-void CreateImageSplicingTaskRequest::setAlign(long align) {
-  align_ = align;
-  setParameter(std::string("Align"), std::to_string(align));
-}
-
 long CreateImageSplicingTaskRequest::getQuality() const {
   return quality_;
 }
@@ -106,15 +110,6 @@ void CreateImageSplicingTaskRequest::setQuality(long quality) {
   setParameter(std::string("Quality"), std::to_string(quality));
 }
 
-std::string CreateImageSplicingTaskRequest::getBackgroundColor() const {
-  return backgroundColor_;
-}
-
-void CreateImageSplicingTaskRequest::setBackgroundColor(const std::string &backgroundColor) {
-  backgroundColor_ = backgroundColor;
-  setParameter(std::string("BackgroundColor"), backgroundColor);
-}
-
 std::map<std::string, std::string> CreateImageSplicingTaskRequest::getTags() const {
   return tags_;
 }
@@ -126,6 +121,18 @@ void CreateImageSplicingTaskRequest::setTags(const std::map<std::string, std::st
   }
 }
 
+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_;
 }
@@ -135,15 +142,6 @@ void CreateImageSplicingTaskRequest::setUserData(const std::string &userData) {
   setParameter(std::string("UserData"), userData);
 }
 
-std::string CreateImageSplicingTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateImageSplicingTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
 std::string CreateImageSplicingTaskRequest::getTargetURI() const {
   return targetURI_;
 }
@@ -153,15 +151,6 @@ void CreateImageSplicingTaskRequest::setTargetURI(const std::string &targetURI)
   setParameter(std::string("TargetURI"), targetURI);
 }
 
-std::string CreateImageSplicingTaskRequest::getScaleType() const {
-  return scaleType_;
-}
-
-void CreateImageSplicingTaskRequest::setScaleType(const std::string &scaleType) {
-  scaleType_ = scaleType;
-  setParameter(std::string("ScaleType"), scaleType);
-}
-
 std::string CreateImageSplicingTaskRequest::getImageFormat() const {
   return imageFormat_;
 }
@@ -180,3 +169,27 @@ void CreateImageSplicingTaskRequest::setDirection(const std::string &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/CreateImageToPDFTaskRequest.cc

@@ -0,0 +1,123 @@
+/*
+ * 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/CreateImageToPDFTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateImageToPDFTaskRequest;
+
+CreateImageToPDFTaskRequest::CreateImageToPDFTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateImageToPDFTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateImageToPDFTaskRequest::~CreateImageToPDFTaskRequest() {}
+
+std::vector<CreateImageToPDFTaskRequest::Sources> CreateImageToPDFTaskRequest::getSources() const {
+  return sources_;
+}
+
+void CreateImageToPDFTaskRequest::setSources(const std::vector<CreateImageToPDFTaskRequest::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 CreateImageToPDFTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateImageToPDFTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+CreateImageToPDFTaskRequest::Notification CreateImageToPDFTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateImageToPDFTaskRequest::setNotification(const CreateImageToPDFTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+std::string CreateImageToPDFTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateImageToPDFTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateImageToPDFTaskRequest::getTargetURI() const {
+  return targetURI_;
+}
+
+void CreateImageToPDFTaskRequest::setTargetURI(const std::string &targetURI) {
+  targetURI_ = targetURI;
+  setParameter(std::string("TargetURI"), targetURI);
+}
+
+std::string CreateImageToPDFTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateImageToPDFTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateImageToPDFTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateImageToPDFTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+CreateImageToPDFTaskRequest::CredentialConfig CreateImageToPDFTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateImageToPDFTaskRequest::setCredentialConfig(const CreateImageToPDFTaskRequest::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> CreateImageToPDFTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateImageToPDFTaskRequest::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/CreateImageToPDFTaskResult.cc

@@ -14,45 +14,45 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/CreateGrabFrameTaskResult.h>
+#include <alibabacloud/imm/model/CreateImageToPDFTaskResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-CreateGrabFrameTaskResult::CreateGrabFrameTaskResult() :
+CreateImageToPDFTaskResult::CreateImageToPDFTaskResult() :
 	ServiceResult()
 {}
 
-CreateGrabFrameTaskResult::CreateGrabFrameTaskResult(const std::string &payload) :
+CreateImageToPDFTaskResult::CreateImageToPDFTaskResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateGrabFrameTaskResult::~CreateGrabFrameTaskResult()
+CreateImageToPDFTaskResult::~CreateImageToPDFTaskResult()
 {}
 
-void CreateGrabFrameTaskResult::parse(const std::string &payload)
+void CreateImageToPDFTaskResult::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 CreateGrabFrameTaskResult::getTaskId()const
+std::string CreateImageToPDFTaskResult::getTaskId()const
 {
 	return taskId_;
 }
 
-std::string CreateGrabFrameTaskResult::getTaskType()const
+std::string CreateImageToPDFTaskResult::getEventId()const
 {
-	return taskType_;
+	return eventId_;
 }
 

imm/src/model/CreateLocationDateClusteringTaskRequest.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/CreateLocationDateClusteringTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateLocationDateClusteringTaskRequest;
+
+CreateLocationDateClusteringTaskRequest::CreateLocationDateClusteringTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateLocationDateClusteringTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateLocationDateClusteringTaskRequest::~CreateLocationDateClusteringTaskRequest() {}
+
+std::string CreateLocationDateClusteringTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateLocationDateClusteringTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+CreateLocationDateClusteringTaskRequest::Notification CreateLocationDateClusteringTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateLocationDateClusteringTaskRequest::setNotification(const CreateLocationDateClusteringTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+std::string CreateLocationDateClusteringTaskRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void CreateLocationDateClusteringTaskRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string CreateLocationDateClusteringTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateLocationDateClusteringTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+CreateLocationDateClusteringTaskRequest::LocationOptions CreateLocationDateClusteringTaskRequest::getLocationOptions() const {
+  return locationOptions_;
+}
+
+void CreateLocationDateClusteringTaskRequest::setLocationOptions(const CreateLocationDateClusteringTaskRequest::LocationOptions &locationOptions) {
+  locationOptions_ = locationOptions;
+  for(int dep1 = 0; dep1 != locationOptions.locationDateClusterLevels.size(); dep1++) {
+    setParameter(std::string("LocationOptions") + ".LocationDateClusterLevels." + std::to_string(dep1 + 1), locationOptions.locationDateClusterLevels[dep1]);
+  }
+}
+
+std::string CreateLocationDateClusteringTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateLocationDateClusteringTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+std::string CreateLocationDateClusteringTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateLocationDateClusteringTaskRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+
+CreateLocationDateClusteringTaskRequest::DateOptions CreateLocationDateClusteringTaskRequest::getDateOptions() const {
+  return dateOptions_;
+}
+
+void CreateLocationDateClusteringTaskRequest::setDateOptions(const CreateLocationDateClusteringTaskRequest::DateOptions &dateOptions) {
+  dateOptions_ = dateOptions;
+  setParameter(std::string("DateOptions") + ".MinDays", std::to_string(dateOptions.minDays));
+  setParameter(std::string("DateOptions") + ".GapDays", std::to_string(dateOptions.gapDays));
+  setParameter(std::string("DateOptions") + ".MaxDays", std::to_string(dateOptions.maxDays));
+}
+

imm/src/model/CreateLocationDateClusteringTaskResult.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/CreateLocationDateClusteringTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateLocationDateClusteringTaskResult::CreateLocationDateClusteringTaskResult() :
+	ServiceResult()
+{}
+
+CreateLocationDateClusteringTaskResult::CreateLocationDateClusteringTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateLocationDateClusteringTaskResult::~CreateLocationDateClusteringTaskResult()
+{}
+
+void CreateLocationDateClusteringTaskResult::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 CreateLocationDateClusteringTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string CreateLocationDateClusteringTaskResult::getEventId()const
+{
+	return eventId_;
+}
+

imm/src/model/CreateMediaConvertTaskRequest.cc

@@ -25,33 +25,6 @@ CreateMediaConvertTaskRequest::CreateMediaConvertTaskRequest()
 
 CreateMediaConvertTaskRequest::~CreateMediaConvertTaskRequest() {}
 
-std::string CreateMediaConvertTaskRequest::getUserData() const {
-  return userData_;
-}
-
-void CreateMediaConvertTaskRequest::setUserData(const std::string &userData) {
-  userData_ = userData;
-  setParameter(std::string("UserData"), userData);
-}
-
-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);
-}
-
 std::vector<CreateMediaConvertTaskRequest::Sources> CreateMediaConvertTaskRequest::getSources() const {
   return sources_;
 }
@@ -70,30 +43,6 @@ void CreateMediaConvertTaskRequest::setSources(const std::vector<CreateMediaConv
   }
 }
 
-std::string CreateMediaConvertTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateMediaConvertTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-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::vector<CreateMediaConvertTaskRequest::Targets> CreateMediaConvertTaskRequest::getTargets() const {
   return targets_;
 }
@@ -112,6 +61,17 @@ void CreateMediaConvertTaskRequest::setTargets(const std::vector<CreateMediaConv
       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.animations.size(); dep2++) {
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Animations." + std::to_string(dep2 + 1) + ".Number", std::to_string(targets[dep1].image.animations[dep2].number));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Animations." + std::to_string(dep2 + 1) + ".FrameRate", std::to_string(targets[dep1].image.animations[dep2].frameRate));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Animations." + std::to_string(dep2 + 1) + ".Format", targets[dep1].image.animations[dep2].format);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Animations." + std::to_string(dep2 + 1) + ".Width", std::to_string(targets[dep1].image.animations[dep2].width));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Animations." + std::to_string(dep2 + 1) + ".Interval", std::to_string(targets[dep1].image.animations[dep2].interval));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Animations." + std::to_string(dep2 + 1) + ".StartTime", std::to_string(targets[dep1].image.animations[dep2].startTime));
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Animations." + std::to_string(dep2 + 1) + ".ScaleType", targets[dep1].image.animations[dep2].scaleType);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Animations." + std::to_string(dep2 + 1) + ".URI", targets[dep1].image.animations[dep2].uRI);
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Image.Animations." + std::to_string(dep2 + 1) + ".Height", std::to_string(targets[dep1].image.animations[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));
@@ -131,8 +91,12 @@ void CreateMediaConvertTaskRequest::setTargets(const std::vector<CreateMediaConv
     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");
+    for(int dep2 = 0; dep2 != targets[dep1].subtitle.stream.size(); dep2++) {
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Subtitle.Stream." + std::to_string(dep2 + 1), std::to_string(targets[dep1].subtitle.stream[dep2]));
+    }
     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) + ".StripMetadata", targets[dep1].stripMetadata ? "true" : "false");
     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++) {
@@ -162,6 +126,9 @@ void CreateMediaConvertTaskRequest::setTargets(const std::vector<CreateMediaConv
       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));
     }
+    for(int dep2 = 0; dep2 != targets[dep1].video.stream.size(); dep2++) {
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Video.Stream." + std::to_string(dep2 + 1), std::to_string(targets[dep1].video.stream[dep2]));
+    }
     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));
@@ -180,6 +147,9 @@ void CreateMediaConvertTaskRequest::setTargets(const std::vector<CreateMediaConv
     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");
+    for(int dep2 = 0; dep2 != targets[dep1].audio.stream.size(); dep2++) {
+      setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".Audio.Stream." + std::to_string(dep2 + 1), std::to_string(targets[dep1].audio.stream[dep2]));
+    }
     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);
@@ -191,9 +161,74 @@ void CreateMediaConvertTaskRequest::setTargets(const std::vector<CreateMediaConv
     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));
+    setParameter(std::string("Targets") + "." + std::to_string(dep1 + 1) + ".PTSOffset", std::to_string(targets[dep1].pTSOffset));
   }
 }
 
+std::string CreateMediaConvertTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateMediaConvertTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+CreateMediaConvertTaskRequest::Notification CreateMediaConvertTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateMediaConvertTaskRequest::setNotification(const CreateMediaConvertTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+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_;
 }

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,41 @@
 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);
+void CreateOfficeConversionTaskRequest::setShowComments(bool showComments) {
+  showComments_ = showComments;
+  setParameter(std::string("ShowComments"), showComments ? "true" : "false");
 }
 
-std::string CreateOfficeConversionTaskRequest::getIdempotentToken() const {
-  return idempotentToken_;
+CreateOfficeConversionTaskRequest::Notification CreateOfficeConversionTaskRequest::getNotification() const {
+  return notification_;
 }
 
-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::setNotification(const CreateOfficeConversionTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
 }
 
 std::string CreateOfficeConversionTaskRequest::getPassword() const {
@@ -88,13 +65,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 +83,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 +110,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 +128,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

@@ -25,13 +25,40 @@ CreateProjectRequest::CreateProjectRequest()
 
 CreateProjectRequest::~CreateProjectRequest() {}
 
-long CreateProjectRequest::getEngineConcurrency() const {
-  return engineConcurrency_;
+long CreateProjectRequest::getDatasetMaxBindCount() const {
+  return datasetMaxBindCount_;
 }
 
-void CreateProjectRequest::setEngineConcurrency(long engineConcurrency) {
-  engineConcurrency_ = engineConcurrency;
-  setParameter(std::string("EngineConcurrency"), std::to_string(engineConcurrency));
+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::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 {
@@ -43,15 +70,6 @@ void CreateProjectRequest::setProjectName(const std::string &projectName) {
   setParameter(std::string("ProjectName"), projectName);
 }
 
-long CreateProjectRequest::getDatasetMaxBindCount() const {
-  return datasetMaxBindCount_;
-}
-
-void CreateProjectRequest::setDatasetMaxBindCount(long datasetMaxBindCount) {
-  datasetMaxBindCount_ = datasetMaxBindCount;
-  setParameter(std::string("DatasetMaxBindCount"), std::to_string(datasetMaxBindCount));
-}
-
 long CreateProjectRequest::getProjectMaxDatasetCount() const {
   return projectMaxDatasetCount_;
 }
@@ -61,6 +79,24 @@ void CreateProjectRequest::setProjectMaxDatasetCount(long 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_;
 }
@@ -79,57 +115,3 @@ void CreateProjectRequest::setServiceRole(const std::string &serviceRole) {
   setParameter(std::string("ServiceRole"), serviceRole);
 }
 
-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));
-}
-
-std::string CreateProjectRequest::getDescription() const {
-  return description_;
-}
-
-void CreateProjectRequest::setDescription(const std::string &description) {
-  description_ = description;
-  setParameter(std::string("Description"), description);
-}
-
-long CreateProjectRequest::getDatasetMaxEntityCount() const {
-  return datasetMaxEntityCount_;
-}
-
-void CreateProjectRequest::setDatasetMaxEntityCount(long datasetMaxEntityCount) {
-  datasetMaxEntityCount_ = datasetMaxEntityCount;
-  setParameter(std::string("DatasetMaxEntityCount"), std::to_string(datasetMaxEntityCount));
-}
-
-long CreateProjectRequest::getDatasetMaxFileCount() const {
-  return datasetMaxFileCount_;
-}
-
-void CreateProjectRequest::setDatasetMaxFileCount(long datasetMaxFileCount) {
-  datasetMaxFileCount_ = datasetMaxFileCount;
-  setParameter(std::string("DatasetMaxFileCount"), std::to_string(datasetMaxFileCount));
-}
-
-std::string CreateProjectRequest::getTemplateId() const {
-  return templateId_;
-}
-
-void CreateProjectRequest::setTemplateId(const std::string &templateId) {
-  templateId_ = templateId;
-  setParameter(std::string("TemplateId"), templateId);
-}
-

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/CreateSimilarImageClusteringTaskRequest.cc

@@ -0,0 +1,85 @@
+/*
+ * 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/CreateSimilarImageClusteringTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateSimilarImageClusteringTaskRequest;
+
+CreateSimilarImageClusteringTaskRequest::CreateSimilarImageClusteringTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateSimilarImageClusteringTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateSimilarImageClusteringTaskRequest::~CreateSimilarImageClusteringTaskRequest() {}
+
+std::string CreateSimilarImageClusteringTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateSimilarImageClusteringTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+CreateSimilarImageClusteringTaskRequest::Notification CreateSimilarImageClusteringTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateSimilarImageClusteringTaskRequest::setNotification(const CreateSimilarImageClusteringTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+std::string CreateSimilarImageClusteringTaskRequest::getDatasetName() const {
+  return datasetName_;
+}
+
+void CreateSimilarImageClusteringTaskRequest::setDatasetName(const std::string &datasetName) {
+  datasetName_ = datasetName;
+  setParameter(std::string("DatasetName"), datasetName);
+}
+
+std::string CreateSimilarImageClusteringTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateSimilarImageClusteringTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateSimilarImageClusteringTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateSimilarImageClusteringTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+std::string CreateSimilarImageClusteringTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateSimilarImageClusteringTaskRequest::setTags(const std::string &tags) {
+  tags_ = tags;
+  setParameter(std::string("Tags"), tags);
+}
+

imm/src/model/CreateSimilarImageClusteringTaskResult.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/CreateSimilarImageClusteringTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateSimilarImageClusteringTaskResult::CreateSimilarImageClusteringTaskResult() :
+	ServiceResult()
+{}
+
+CreateSimilarImageClusteringTaskResult::CreateSimilarImageClusteringTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateSimilarImageClusteringTaskResult::~CreateSimilarImageClusteringTaskResult()
+{}
+
+void CreateSimilarImageClusteringTaskResult::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 CreateSimilarImageClusteringTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string CreateSimilarImageClusteringTaskResult::getEventId()const
+{
+	return eventId_;
+}
+

imm/src/model/CreateStoryRequest.cc

@@ -25,24 +25,6 @@ CreateStoryRequest::CreateStoryRequest()
 
 CreateStoryRequest::~CreateStoryRequest() {}
 
-long CreateStoryRequest::getMinFileCount() const {
-  return minFileCount_;
-}
-
-void CreateStoryRequest::setMinFileCount(long minFileCount) {
-  minFileCount_ = minFileCount;
-  setBodyParameter(std::string("MinFileCount"), std::to_string(minFileCount));
-}
-
-std::string CreateStoryRequest::getProjectName() const {
-  return projectName_;
-}
-
-void CreateStoryRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setBodyParameter(std::string("ProjectName"), projectName);
-}
-
 std::string CreateStoryRequest::getCustomLabels() const {
   return customLabels_;
 }
@@ -52,13 +34,35 @@ void CreateStoryRequest::setCustomLabels(const std::string &customLabels) {
   setBodyParameter(std::string("CustomLabels"), customLabels);
 }
 
-std::string CreateStoryRequest::getStoryStartTime() const {
-  return storyStartTime_;
+CreateStoryRequest::Notification CreateStoryRequest::getNotification() const {
+  return notification_;
 }
 
-void CreateStoryRequest::setStoryStartTime(const std::string &storyStartTime) {
-  storyStartTime_ = storyStartTime;
-  setBodyParameter(std::string("StoryStartTime"), storyStartTime);
+void CreateStoryRequest::setNotification(const CreateStoryRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+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 {
@@ -79,15 +83,6 @@ void CreateStoryRequest::setStoryType(const std::string &storyType) {
   setBodyParameter(std::string("StoryType"), storyType);
 }
 
-std::string CreateStoryRequest::getCustomId() const {
-  return customId_;
-}
-
-void CreateStoryRequest::setCustomId(const std::string &customId) {
-  customId_ = customId;
-  setBodyParameter(std::string("CustomId"), customId);
-}
-
 std::map<std::string, std::string> CreateStoryRequest::getTags() const {
   return tags_;
 }
@@ -99,6 +94,24 @@ void CreateStoryRequest::setTags(const std::map<std::string, std::string> &tags)
   }
 }
 
+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_;
 }
@@ -108,15 +121,6 @@ void CreateStoryRequest::setUserData(const std::string &userData) {
   setParameter(std::string("UserData"), userData);
 }
 
-std::string CreateStoryRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateStoryRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setBodyParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
 long CreateStoryRequest::getMaxFileCount() const {
   return maxFileCount_;
 }
@@ -126,15 +130,6 @@ void CreateStoryRequest::setMaxFileCount(long maxFileCount) {
   setBodyParameter(std::string("MaxFileCount"), std::to_string(maxFileCount));
 }
 
-std::string CreateStoryRequest::getStorySubType() const {
-  return storySubType_;
-}
-
-void CreateStoryRequest::setStorySubType(const std::string &storySubType) {
-  storySubType_ = storySubType;
-  setBodyParameter(std::string("StorySubType"), storySubType);
-}
-
 std::string CreateStoryRequest::getDatasetName() const {
   return datasetName_;
 }
@@ -144,6 +139,37 @@ void CreateStoryRequest::setDatasetName(const std::string &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);
+}
+
+CreateStoryRequest::Address CreateStoryRequest::getAddress() const {
+  return address_;
+}
+
+void CreateStoryRequest::setAddress(const CreateStoryRequest::Address &address) {
+  address_ = address;
+  setBodyParameter(std::string("Address") + ".Country", address.country);
+  setBodyParameter(std::string("Address") + ".Province", address.province);
+  setBodyParameter(std::string("Address") + ".City", address.city);
+  setBodyParameter(std::string("Address") + ".District", address.district);
+  setBodyParameter(std::string("Address") + ".Township", address.township);
+}
+
+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_;
 }

imm/src/model/CreateTriggerRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * 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/CreateTriggerRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateTriggerRequest;
+
+CreateTriggerRequest::CreateTriggerRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateTrigger") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateTriggerRequest::~CreateTriggerRequest() {}
+
+CreateTriggerRequest::Notification CreateTriggerRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateTriggerRequest::setNotification(const CreateTriggerRequest::Notification &notification) {
+  notification_ = notification;
+  setBodyParameter(std::string("Notification") + ".Endpoint", notification.endpoint);
+  setBodyParameter(std::string("Notification") + ".Topic", notification.topic);
+}
+
+std::string CreateTriggerRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateTriggerRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setBodyParameter(std::string("ProjectName"), projectName);
+}
+
+std::map<std::string, std::string> CreateTriggerRequest::getTags() const {
+  return tags_;
+}
+
+void CreateTriggerRequest::setTags(const std::map<std::string, std::string> &tags) {
+  tags_ = tags;
+  for(auto const &iter1 : tags) {
+    setBodyParameter(std::string("Tags") + "." + iter1.first, iter1.second);
+  }
+}
+
+CreateTriggerRequest::Input CreateTriggerRequest::getInput() const {
+  return input_;
+}
+
+void CreateTriggerRequest::setInput(const CreateTriggerRequest::Input &input) {
+  input_ = input;
+  setBodyParameter(std::string("Input") + ".OSS.Bucket", input.oSS.bucket);
+  setBodyParameter(std::string("Input") + ".OSS.Prefix", input.oSS.prefix);
+  for(int dep1 = 0; dep1 != input.oSS.matchExpressions.size(); dep1++) {
+    setBodyParameter(std::string("Input") + ".OSS.MatchExpressions." + std::to_string(dep1 + 1), input.oSS.matchExpressions[dep1]);
+  }
+}
+
+std::string CreateTriggerRequest::getServiceRole() const {
+  return serviceRole_;
+}
+
+void CreateTriggerRequest::setServiceRole(const std::string &serviceRole) {
+  serviceRole_ = serviceRole;
+  setBodyParameter(std::string("ServiceRole"), serviceRole);
+}
+
+std::vector<CreateTriggerRequest::Actions> CreateTriggerRequest::getActions() const {
+  return actions_;
+}
+
+void CreateTriggerRequest::setActions(const std::vector<CreateTriggerRequest::Actions> &actions) {
+  actions_ = actions;
+  for(int dep1 = 0; dep1 != actions.size(); dep1++) {
+    setBodyParameter(std::string("Actions") + "." + std::to_string(dep1 + 1) + ".Name", actions[dep1].name);
+    for(int dep2 = 0; dep2 != actions[dep1].parameters.size(); dep2++) {
+      setBodyParameter(std::string("Actions") + "." + std::to_string(dep1 + 1) + ".Parameters." + std::to_string(dep2 + 1), actions[dep1].parameters[dep2]);
+    }
+  }
+}
+

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

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/CreateVideoLabelClassificationTaskRequest.cc

@@ -0,0 +1,111 @@
+/*
+ * 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/CreateVideoLabelClassificationTaskRequest.h>
+
+using AlibabaCloud::Imm::Model::CreateVideoLabelClassificationTaskRequest;
+
+CreateVideoLabelClassificationTaskRequest::CreateVideoLabelClassificationTaskRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "CreateVideoLabelClassificationTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateVideoLabelClassificationTaskRequest::~CreateVideoLabelClassificationTaskRequest() {}
+
+std::string CreateVideoLabelClassificationTaskRequest::getUserData() const {
+  return userData_;
+}
+
+void CreateVideoLabelClassificationTaskRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
+CreateVideoLabelClassificationTaskRequest::Notification CreateVideoLabelClassificationTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateVideoLabelClassificationTaskRequest::setNotification(const CreateVideoLabelClassificationTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+std::string CreateVideoLabelClassificationTaskRequest::getNotifyEndpoint() const {
+  return notifyEndpoint_;
+}
+
+void CreateVideoLabelClassificationTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
+  notifyEndpoint_ = notifyEndpoint;
+  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
+}
+
+std::string CreateVideoLabelClassificationTaskRequest::getProjectName() const {
+  return projectName_;
+}
+
+void CreateVideoLabelClassificationTaskRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+std::string CreateVideoLabelClassificationTaskRequest::getNotifyTopicName() const {
+  return notifyTopicName_;
+}
+
+void CreateVideoLabelClassificationTaskRequest::setNotifyTopicName(const std::string &notifyTopicName) {
+  notifyTopicName_ = notifyTopicName;
+  setParameter(std::string("NotifyTopicName"), notifyTopicName);
+}
+
+CreateVideoLabelClassificationTaskRequest::CredentialConfig CreateVideoLabelClassificationTaskRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void CreateVideoLabelClassificationTaskRequest::setCredentialConfig(const CreateVideoLabelClassificationTaskRequest::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> CreateVideoLabelClassificationTaskRequest::getTags() const {
+  return tags_;
+}
+
+void CreateVideoLabelClassificationTaskRequest::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 CreateVideoLabelClassificationTaskRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void CreateVideoLabelClassificationTaskRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/CreateVideoLabelClassificationTaskResult.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/CreateVideoLabelClassificationTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+CreateVideoLabelClassificationTaskResult::CreateVideoLabelClassificationTaskResult() :
+	ServiceResult()
+{}
+
+CreateVideoLabelClassificationTaskResult::CreateVideoLabelClassificationTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateVideoLabelClassificationTaskResult::~CreateVideoLabelClassificationTaskResult()
+{}
+
+void CreateVideoLabelClassificationTaskResult::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();
+
+}
+
+std::string CreateVideoLabelClassificationTaskResult::getTaskId()const
+{
+	return taskId_;
+}
+
+std::string CreateVideoLabelClassificationTaskResult::getEventId()const
+{
+	return eventId_;
+}
+

imm/src/model/CreateVideoModerationTaskRequest.cc

@@ -34,6 +34,28 @@ void CreateVideoModerationTaskRequest::setUserData(const std::string &userData)
   setParameter(std::string("UserData"), userData);
 }
 
+CreateVideoModerationTaskRequest::Notification CreateVideoModerationTaskRequest::getNotification() const {
+  return notification_;
+}
+
+void CreateVideoModerationTaskRequest::setNotification(const CreateVideoModerationTaskRequest::Notification &notification) {
+  notification_ = notification;
+  setParameter(std::string("Notification") + ".MNS.Endpoint", notification.mNS.endpoint);
+  setParameter(std::string("Notification") + ".MNS.TopicName", notification.mNS.topicName);
+  setParameter(std::string("Notification") + ".RocketMQ.Endpoint", notification.rocketMQ.endpoint);
+  setParameter(std::string("Notification") + ".RocketMQ.InstanceId", notification.rocketMQ.instanceId);
+  setParameter(std::string("Notification") + ".RocketMQ.TopicName", notification.rocketMQ.topicName);
+}
+
+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_;
 }
@@ -52,35 +74,6 @@ void CreateVideoModerationTaskRequest::setNotifyTopicName(const std::string &not
   setParameter(std::string("NotifyTopicName"), notifyTopicName);
 }
 
-std::string CreateVideoModerationTaskRequest::getNotifyEndpoint() const {
-  return notifyEndpoint_;
-}
-
-void CreateVideoModerationTaskRequest::setNotifyEndpoint(const std::string &notifyEndpoint) {
-  notifyEndpoint_ = notifyEndpoint;
-  setParameter(std::string("NotifyEndpoint"), notifyEndpoint);
-}
-
-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::getMaxFrames() const {
   return maxFrames_;
 }
@@ -90,15 +83,6 @@ void CreateVideoModerationTaskRequest::setMaxFrames(long maxFrames) {
   setParameter(std::string("MaxFrames"), std::to_string(maxFrames));
 }
 
-long CreateVideoModerationTaskRequest::getInterval() const {
-  return interval_;
-}
-
-void CreateVideoModerationTaskRequest::setInterval(long interval) {
-  interval_ = interval;
-  setParameter(std::string("Interval"), std::to_string(interval));
-}
-
 CreateVideoModerationTaskRequest::CredentialConfig CreateVideoModerationTaskRequest::getCredentialConfig() const {
   return credentialConfig_;
 }
@@ -134,3 +118,32 @@ void CreateVideoModerationTaskRequest::setTags(const std::map<std::string, std::
   }
 }
 
+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/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,51 +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["TargetUri"].isNull())
-		targetUri_ = value["TargetUri"].asString();
-
-}
-
-std::string DecodeBlindWatermarkResult::getTargetUri()const
-{
-	return targetUri_;
-}
-

imm/src/model/DeleteBatchRequest.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/DeleteBatchRequest.h>
+
+using AlibabaCloud::Imm::Model::DeleteBatchRequest;
+
+DeleteBatchRequest::DeleteBatchRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DeleteBatch") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteBatchRequest::~DeleteBatchRequest() {}
+
+std::string DeleteBatchRequest::getId() const {
+  return id_;
+}
+
+void DeleteBatchRequest::setId(const std::string &id) {
+  id_ = id;
+  setBodyParameter(std::string("Id"), id);
+}
+
+std::string DeleteBatchRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DeleteBatchRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setBodyParameter(std::string("ProjectName"), projectName);
+}
+

imm/src/model/DeleteBatchResult.cc

@@ -14,38 +14,31 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/DeleteSetResult.h>
+#include <alibabacloud/imm/model/DeleteBatchResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-DeleteSetResult::DeleteSetResult() :
+DeleteBatchResult::DeleteBatchResult() :
 	ServiceResult()
 {}
 
-DeleteSetResult::DeleteSetResult(const std::string &payload) :
+DeleteBatchResult::DeleteBatchResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteSetResult::~DeleteSetResult()
+DeleteBatchResult::~DeleteBatchResult()
 {}
 
-void DeleteSetResult::parse(const std::string &payload)
+void DeleteBatchResult::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/DeleteBindingRequest.cc

@@ -25,24 +25,6 @@ DeleteBindingRequest::DeleteBindingRequest()
 
 DeleteBindingRequest::~DeleteBindingRequest() {}
 
-std::string DeleteBindingRequest::getProjectName() const {
-  return projectName_;
-}
-
-void DeleteBindingRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
-bool DeleteBindingRequest::getCleanup() const {
-  return cleanup_;
-}
-
-void DeleteBindingRequest::setCleanup(bool cleanup) {
-  cleanup_ = cleanup;
-  setParameter(std::string("Cleanup"), cleanup ? "true" : "false");
-}
-
 std::string DeleteBindingRequest::getDatasetName() const {
   return datasetName_;
 }
@@ -52,6 +34,15 @@ void DeleteBindingRequest::setDatasetName(const std::string &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_;
 }
@@ -61,3 +52,12 @@ void DeleteBindingRequest::setURI(const std::string &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/DeleteDatasetRequest.cc

@@ -25,15 +25,6 @@ DeleteDatasetRequest::DeleteDatasetRequest()
 
 DeleteDatasetRequest::~DeleteDatasetRequest() {}
 
-std::string DeleteDatasetRequest::getProjectName() const {
-  return projectName_;
-}
-
-void DeleteDatasetRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
 std::string DeleteDatasetRequest::getDatasetName() const {
   return datasetName_;
 }
@@ -43,3 +34,12 @@ void DeleteDatasetRequest::setDatasetName(const std::string &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/DeleteFileMetaRequest.cc

@@ -25,15 +25,6 @@ DeleteFileMetaRequest::DeleteFileMetaRequest()
 
 DeleteFileMetaRequest::~DeleteFileMetaRequest() {}
 
-std::string DeleteFileMetaRequest::getProjectName() const {
-  return projectName_;
-}
-
-void DeleteFileMetaRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
 std::string DeleteFileMetaRequest::getDatasetName() const {
   return datasetName_;
 }
@@ -43,6 +34,15 @@ void DeleteFileMetaRequest::setDatasetName(const std::string &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_;
 }

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

imm/src/model/DeleteLocationDateClusterResult.cc

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

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

@@ -25,15 +25,6 @@ DeleteStoryRequest::DeleteStoryRequest()
 
 DeleteStoryRequest::~DeleteStoryRequest() {}
 
-std::string DeleteStoryRequest::getProjectName() const {
-  return projectName_;
-}
-
-void DeleteStoryRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
 std::string DeleteStoryRequest::getDatasetName() const {
   return datasetName_;
 }
@@ -43,6 +34,15 @@ void DeleteStoryRequest::setDatasetName(const std::string &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_;
 }

imm/src/model/DeleteTriggerRequest.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/DeleteTriggerRequest.h>
+
+using AlibabaCloud::Imm::Model::DeleteTriggerRequest;
+
+DeleteTriggerRequest::DeleteTriggerRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DeleteTrigger") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTriggerRequest::~DeleteTriggerRequest() {}
+
+std::string DeleteTriggerRequest::getId() const {
+  return id_;
+}
+
+void DeleteTriggerRequest::setId(const std::string &id) {
+  id_ = id;
+  setBodyParameter(std::string("Id"), id);
+}
+
+std::string DeleteTriggerRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DeleteTriggerRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setBodyParameter(std::string("ProjectName"), projectName);
+}
+

imm/src/model/DeleteTriggerResult.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/DeleteTriggerResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DeleteTriggerResult::DeleteTriggerResult() :
+	ServiceResult()
+{}
+
+DeleteTriggerResult::DeleteTriggerResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteTriggerResult::~DeleteTriggerResult()
+{}
+
+void DeleteTriggerResult::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/DeleteVideoResult.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/DeleteVideoResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Imm;
-using namespace AlibabaCloud::Imm::Model;
-
-DeleteVideoResult::DeleteVideoResult() :
-	ServiceResult()
-{}
-
-DeleteVideoResult::DeleteVideoResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DeleteVideoResult::~DeleteVideoResult()
-{}
-
-void DeleteVideoResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	if(!value["VideoUri"].isNull())
-		videoUri_ = value["VideoUri"].asString();
-	if(!value["SetId"].isNull())
-		setId_ = value["SetId"].asString();
-
-}
-
-std::string DeleteVideoResult::getVideoUri()const
-{
-	return videoUri_;
-}
-
-std::string DeleteVideoResult::getSetId()const
-{
-	return 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/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/DetectImageCarsRequest.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/DetectImageCarsRequest.h>
+
+using AlibabaCloud::Imm::Model::DetectImageCarsRequest;
+
+DetectImageCarsRequest::DetectImageCarsRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DetectImageCars") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetectImageCarsRequest::~DetectImageCarsRequest() {}
+
+std::string DetectImageCarsRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DetectImageCarsRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+DetectImageCarsRequest::CredentialConfig DetectImageCarsRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void DetectImageCarsRequest::setCredentialConfig(const DetectImageCarsRequest::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 DetectImageCarsRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void DetectImageCarsRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/DetectImageCarsResult.cc

@@ -0,0 +1,93 @@
+/*
+ * 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/DetectImageCarsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DetectImageCarsResult::DetectImageCarsResult() :
+	ServiceResult()
+{}
+
+DetectImageCarsResult::DetectImageCarsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectImageCarsResult::~DetectImageCarsResult()
+{}
+
+void DetectImageCarsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCarsNode = value["Cars"]["CarsItem"];
+	for (auto valueCarsCarsItem : allCarsNode)
+	{
+		CarsItem carsObject;
+		if(!valueCarsCarsItem["CarType"].isNull())
+			carsObject.carType = valueCarsCarsItem["CarType"].asString();
+		if(!valueCarsCarsItem["CarTypeConfidence"].isNull())
+			carsObject.carTypeConfidence = valueCarsCarsItem["CarTypeConfidence"].asString();
+		if(!valueCarsCarsItem["CarColor"].isNull())
+			carsObject.carColor = valueCarsCarsItem["CarColor"].asString();
+		if(!valueCarsCarsItem["CarColorConfidence"].isNull())
+			carsObject.carColorConfidence = valueCarsCarsItem["CarColorConfidence"].asString();
+		if(!valueCarsCarsItem["Confidence"].isNull())
+			carsObject.confidence = valueCarsCarsItem["Confidence"].asString();
+		auto allLicensePlatesNode = valueCarsCarsItem["LicensePlates"]["LicensePlatesItem"];
+		for (auto valueCarsCarsItemLicensePlatesLicensePlatesItem : allLicensePlatesNode)
+		{
+			CarsItem::LicensePlatesItem licensePlatesObject;
+			if(!valueCarsCarsItemLicensePlatesLicensePlatesItem["Content"].isNull())
+				licensePlatesObject.content = valueCarsCarsItemLicensePlatesLicensePlatesItem["Content"].asString();
+			if(!valueCarsCarsItemLicensePlatesLicensePlatesItem["Confidence"].isNull())
+				licensePlatesObject.confidence = valueCarsCarsItemLicensePlatesLicensePlatesItem["Confidence"].asString();
+			auto boundary1Node = value["Boundary"];
+			if(!boundary1Node["Width"].isNull())
+				licensePlatesObject.boundary1.width = std::stol(boundary1Node["Width"].asString());
+			if(!boundary1Node["Height"].isNull())
+				licensePlatesObject.boundary1.height = std::stol(boundary1Node["Height"].asString());
+			if(!boundary1Node["Left"].isNull())
+				licensePlatesObject.boundary1.left = std::stol(boundary1Node["Left"].asString());
+			if(!boundary1Node["Top"].isNull())
+				licensePlatesObject.boundary1.top = std::stol(boundary1Node["Top"].asString());
+			carsObject.licensePlates.push_back(licensePlatesObject);
+		}
+		auto boundaryNode = value["Boundary"];
+		if(!boundaryNode["Width"].isNull())
+			carsObject.boundary.width = std::stol(boundaryNode["Width"].asString());
+		if(!boundaryNode["Height"].isNull())
+			carsObject.boundary.height = std::stol(boundaryNode["Height"].asString());
+		if(!boundaryNode["Left"].isNull())
+			carsObject.boundary.left = std::stol(boundaryNode["Left"].asString());
+		if(!boundaryNode["Top"].isNull())
+			carsObject.boundary.top = std::stol(boundaryNode["Top"].asString());
+		cars_.push_back(carsObject);
+	}
+
+}
+
+std::vector<DetectImageCarsResult::CarsItem> DetectImageCarsResult::getCars()const
+{
+	return cars_;
+}
+

imm/src/model/DetectImageCodesRequest.cc

@@ -34,15 +34,6 @@ void DetectImageCodesRequest::setProjectName(const std::string &projectName) {
   setParameter(std::string("ProjectName"), projectName);
 }
 
-std::string DetectImageCodesRequest::getSourceURI() const {
-  return sourceURI_;
-}
-
-void DetectImageCodesRequest::setSourceURI(const std::string &sourceURI) {
-  sourceURI_ = sourceURI;
-  setParameter(std::string("SourceURI"), sourceURI);
-}
-
 DetectImageCodesRequest::CredentialConfig DetectImageCodesRequest::getCredentialConfig() const {
   return credentialConfig_;
 }
@@ -58,3 +49,12 @@ void DetectImageCodesRequest::setCredentialConfig(const DetectImageCodesRequest:
   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/DetectImageCroppingRequest.cc

@@ -25,24 +25,6 @@ DetectImageCroppingRequest::DetectImageCroppingRequest()
 
 DetectImageCroppingRequest::~DetectImageCroppingRequest() {}
 
-std::string DetectImageCroppingRequest::getProjectName() const {
-  return projectName_;
-}
-
-void DetectImageCroppingRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
-std::string DetectImageCroppingRequest::getSourceURI() const {
-  return sourceURI_;
-}
-
-void DetectImageCroppingRequest::setSourceURI(const std::string &sourceURI) {
-  sourceURI_ = sourceURI;
-  setParameter(std::string("SourceURI"), sourceURI);
-}
-
 std::string DetectImageCroppingRequest::getAspectRatios() const {
   return aspectRatios_;
 }
@@ -52,6 +34,15 @@ void DetectImageCroppingRequest::setAspectRatios(const std::string &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_;
 }
@@ -67,3 +58,12 @@ void DetectImageCroppingRequest::setCredentialConfig(const DetectImageCroppingRe
   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/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

@@ -25,24 +25,6 @@ DetectImageLabelsRequest::DetectImageLabelsRequest()
 
 DetectImageLabelsRequest::~DetectImageLabelsRequest() {}
 
-std::string DetectImageLabelsRequest::getProjectName() const {
-  return projectName_;
-}
-
-void DetectImageLabelsRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
-std::string DetectImageLabelsRequest::getSourceURI() const {
-  return sourceURI_;
-}
-
-void DetectImageLabelsRequest::setSourceURI(const std::string &sourceURI) {
-  sourceURI_ = sourceURI;
-  setParameter(std::string("SourceURI"), sourceURI);
-}
-
 float DetectImageLabelsRequest::getThreshold() const {
   return threshold_;
 }
@@ -52,6 +34,15 @@ void DetectImageLabelsRequest::setThreshold(float 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_;
 }
@@ -67,3 +58,12 @@ void DetectImageLabelsRequest::setCredentialConfig(const DetectImageLabelsReques
   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/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

@@ -34,15 +34,6 @@ void DetectImageScoreRequest::setProjectName(const std::string &projectName) {
   setParameter(std::string("ProjectName"), projectName);
 }
 
-std::string DetectImageScoreRequest::getSourceURI() const {
-  return sourceURI_;
-}
-
-void DetectImageScoreRequest::setSourceURI(const std::string &sourceURI) {
-  sourceURI_ = sourceURI;
-  setParameter(std::string("SourceURI"), sourceURI);
-}
-
 DetectImageScoreRequest::CredentialConfig DetectImageScoreRequest::getCredentialConfig() const {
   return credentialConfig_;
 }
@@ -58,3 +49,12 @@ void DetectImageScoreRequest::setCredentialConfig(const DetectImageScoreRequest:
   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/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/DetectMediaMetaRequest.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/DetectMediaMetaRequest.h>
+
+using AlibabaCloud::Imm::Model::DetectMediaMetaRequest;
+
+DetectMediaMetaRequest::DetectMediaMetaRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "DetectMediaMeta") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetectMediaMetaRequest::~DetectMediaMetaRequest() {}
+
+std::string DetectMediaMetaRequest::getProjectName() const {
+  return projectName_;
+}
+
+void DetectMediaMetaRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+DetectMediaMetaRequest::CredentialConfig DetectMediaMetaRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void DetectMediaMetaRequest::setCredentialConfig(const DetectMediaMetaRequest::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 DetectMediaMetaRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void DetectMediaMetaRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/DetectMediaMetaResult.cc

@@ -0,0 +1,349 @@
+/*
+ * 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/DetectMediaMetaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imm;
+using namespace AlibabaCloud::Imm::Model;
+
+DetectMediaMetaResult::DetectMediaMetaResult() :
+	ServiceResult()
+{}
+
+DetectMediaMetaResult::DetectMediaMetaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectMediaMetaResult::~DetectMediaMetaResult()
+{}
+
+void DetectMediaMetaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allVideoStreamsNode = value["VideoStreams"]["VideoStreamsItem"];
+	for (auto valueVideoStreamsVideoStreamsItem : allVideoStreamsNode)
+	{
+		VideoStreamsItem videoStreamsObject;
+		if(!valueVideoStreamsVideoStreamsItem["Index"].isNull())
+			videoStreamsObject.index = std::stol(valueVideoStreamsVideoStreamsItem["Index"].asString());
+		if(!valueVideoStreamsVideoStreamsItem["Language"].isNull())
+			videoStreamsObject.language = valueVideoStreamsVideoStreamsItem["Language"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["CodecName"].isNull())
+			videoStreamsObject.codecName = valueVideoStreamsVideoStreamsItem["CodecName"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["CodecLongName"].isNull())
+			videoStreamsObject.codecLongName = valueVideoStreamsVideoStreamsItem["CodecLongName"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["Profile"].isNull())
+			videoStreamsObject.profile = valueVideoStreamsVideoStreamsItem["Profile"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["CodecTimeBase"].isNull())
+			videoStreamsObject.codecTimeBase = valueVideoStreamsVideoStreamsItem["CodecTimeBase"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["CodecTagString"].isNull())
+			videoStreamsObject.codecTagString = valueVideoStreamsVideoStreamsItem["CodecTagString"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["CodecTag"].isNull())
+			videoStreamsObject.codecTag = valueVideoStreamsVideoStreamsItem["CodecTag"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["Width"].isNull())
+			videoStreamsObject.width = std::stol(valueVideoStreamsVideoStreamsItem["Width"].asString());
+		if(!valueVideoStreamsVideoStreamsItem["Height"].isNull())
+			videoStreamsObject.height = std::stol(valueVideoStreamsVideoStreamsItem["Height"].asString());
+		if(!valueVideoStreamsVideoStreamsItem["HasBFrames"].isNull())
+			videoStreamsObject.hasBFrames = std::stol(valueVideoStreamsVideoStreamsItem["HasBFrames"].asString());
+		if(!valueVideoStreamsVideoStreamsItem["SampleAspectRatio"].isNull())
+			videoStreamsObject.sampleAspectRatio = valueVideoStreamsVideoStreamsItem["SampleAspectRatio"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["DisplayAspectRatio"].isNull())
+			videoStreamsObject.displayAspectRatio = valueVideoStreamsVideoStreamsItem["DisplayAspectRatio"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["PixelFormat"].isNull())
+			videoStreamsObject.pixelFormat = valueVideoStreamsVideoStreamsItem["PixelFormat"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["Level"].isNull())
+			videoStreamsObject.level = std::stol(valueVideoStreamsVideoStreamsItem["Level"].asString());
+		if(!valueVideoStreamsVideoStreamsItem["FrameRate"].isNull())
+			videoStreamsObject.frameRate = valueVideoStreamsVideoStreamsItem["FrameRate"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["AverageFrameRate"].isNull())
+			videoStreamsObject.averageFrameRate = valueVideoStreamsVideoStreamsItem["AverageFrameRate"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["TimeBase"].isNull())
+			videoStreamsObject.timeBase = valueVideoStreamsVideoStreamsItem["TimeBase"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["StartTime"].isNull())
+			videoStreamsObject.startTime = valueVideoStreamsVideoStreamsItem["StartTime"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["Duration"].isNull())
+			videoStreamsObject.duration = valueVideoStreamsVideoStreamsItem["Duration"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["Bitrate"].isNull())
+			videoStreamsObject.bitrate = std::stol(valueVideoStreamsVideoStreamsItem["Bitrate"].asString());
+		if(!valueVideoStreamsVideoStreamsItem["FrameCount"].isNull())
+			videoStreamsObject.frameCount = std::stol(valueVideoStreamsVideoStreamsItem["FrameCount"].asString());
+		if(!valueVideoStreamsVideoStreamsItem["Rotate"].isNull())
+			videoStreamsObject.rotate = valueVideoStreamsVideoStreamsItem["Rotate"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["BitDepth"].isNull())
+			videoStreamsObject.bitDepth = std::stol(valueVideoStreamsVideoStreamsItem["BitDepth"].asString());
+		if(!valueVideoStreamsVideoStreamsItem["ColorSpace"].isNull())
+			videoStreamsObject.colorSpace = valueVideoStreamsVideoStreamsItem["ColorSpace"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["ColorRange"].isNull())
+			videoStreamsObject.colorRange = valueVideoStreamsVideoStreamsItem["ColorRange"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["ColorTransfer"].isNull())
+			videoStreamsObject.colorTransfer = valueVideoStreamsVideoStreamsItem["ColorTransfer"].asString();
+		if(!valueVideoStreamsVideoStreamsItem["ColorPrimaries"].isNull())
+			videoStreamsObject.colorPrimaries = valueVideoStreamsVideoStreamsItem["ColorPrimaries"].asString();
+		videoStreams_.push_back(videoStreamsObject);
+	}
+	auto allAudioStreamsNode = value["AudioStreams"]["AudioStreamsItem"];
+	for (auto valueAudioStreamsAudioStreamsItem : allAudioStreamsNode)
+	{
+		AudioStreamsItem audioStreamsObject;
+		if(!valueAudioStreamsAudioStreamsItem["Index"].isNull())
+			audioStreamsObject.index = std::stol(valueAudioStreamsAudioStreamsItem["Index"].asString());
+		if(!valueAudioStreamsAudioStreamsItem["Language"].isNull())
+			audioStreamsObject.language = valueAudioStreamsAudioStreamsItem["Language"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["CodecName"].isNull())
+			audioStreamsObject.codecName = valueAudioStreamsAudioStreamsItem["CodecName"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["CodecLongName"].isNull())
+			audioStreamsObject.codecLongName = valueAudioStreamsAudioStreamsItem["CodecLongName"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["CodecTimeBase"].isNull())
+			audioStreamsObject.codecTimeBase = valueAudioStreamsAudioStreamsItem["CodecTimeBase"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["CodecTagString"].isNull())
+			audioStreamsObject.codecTagString = valueAudioStreamsAudioStreamsItem["CodecTagString"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["CodecTag"].isNull())
+			audioStreamsObject.codecTag = valueAudioStreamsAudioStreamsItem["CodecTag"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["TimeBase"].isNull())
+			audioStreamsObject.timeBase = valueAudioStreamsAudioStreamsItem["TimeBase"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["StartTime"].isNull())
+			audioStreamsObject.startTime = valueAudioStreamsAudioStreamsItem["StartTime"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["Duration"].isNull())
+			audioStreamsObject.duration = valueAudioStreamsAudioStreamsItem["Duration"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["Bitrate"].isNull())
+			audioStreamsObject.bitrate = std::stol(valueAudioStreamsAudioStreamsItem["Bitrate"].asString());
+		if(!valueAudioStreamsAudioStreamsItem["FrameCount"].isNull())
+			audioStreamsObject.frameCount = std::stol(valueAudioStreamsAudioStreamsItem["FrameCount"].asString());
+		if(!valueAudioStreamsAudioStreamsItem["Lyric"].isNull())
+			audioStreamsObject.lyric = valueAudioStreamsAudioStreamsItem["Lyric"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["SampleFormat"].isNull())
+			audioStreamsObject.sampleFormat = valueAudioStreamsAudioStreamsItem["SampleFormat"].asString();
+		if(!valueAudioStreamsAudioStreamsItem["SampleRate"].isNull())
+			audioStreamsObject.sampleRate = std::stol(valueAudioStreamsAudioStreamsItem["SampleRate"].asString());
+		if(!valueAudioStreamsAudioStreamsItem["Channels"].isNull())
+			audioStreamsObject.channels = std::stol(valueAudioStreamsAudioStreamsItem["Channels"].asString());
+		if(!valueAudioStreamsAudioStreamsItem["ChannelLayout"].isNull())
+			audioStreamsObject.channelLayout = valueAudioStreamsAudioStreamsItem["ChannelLayout"].asString();
+		audioStreams_.push_back(audioStreamsObject);
+	}
+	auto allSubtitlesNode = value["Subtitles"]["SubtitlesItem"];
+	for (auto valueSubtitlesSubtitlesItem : allSubtitlesNode)
+	{
+		SubtitlesItem subtitlesObject;
+		if(!valueSubtitlesSubtitlesItem["Index"].isNull())
+			subtitlesObject.index = std::stol(valueSubtitlesSubtitlesItem["Index"].asString());
+		if(!valueSubtitlesSubtitlesItem["Language"].isNull())
+			subtitlesObject.language = valueSubtitlesSubtitlesItem["Language"].asString();
+		if(!valueSubtitlesSubtitlesItem["CodecName"].isNull())
+			subtitlesObject.codecName = valueSubtitlesSubtitlesItem["CodecName"].asString();
+		if(!valueSubtitlesSubtitlesItem["CodecLongName"].isNull())
+			subtitlesObject.codecLongName = valueSubtitlesSubtitlesItem["CodecLongName"].asString();
+		if(!valueSubtitlesSubtitlesItem["CodecTagString"].isNull())
+			subtitlesObject.codecTagString = valueSubtitlesSubtitlesItem["CodecTagString"].asString();
+		if(!valueSubtitlesSubtitlesItem["CodecTag"].isNull())
+			subtitlesObject.codecTag = valueSubtitlesSubtitlesItem["CodecTag"].asString();
+		if(!valueSubtitlesSubtitlesItem["StartTime"].isNull())
+			subtitlesObject.startTime = valueSubtitlesSubtitlesItem["StartTime"].asString();
+		if(!valueSubtitlesSubtitlesItem["Duration"].isNull())
+			subtitlesObject.duration = valueSubtitlesSubtitlesItem["Duration"].asString();
+		if(!valueSubtitlesSubtitlesItem["Bitrate"].isNull())
+			subtitlesObject.bitrate = std::stol(valueSubtitlesSubtitlesItem["Bitrate"].asString());
+		if(!valueSubtitlesSubtitlesItem["Content"].isNull())
+			subtitlesObject.content = valueSubtitlesSubtitlesItem["Content"].asString();
+		if(!valueSubtitlesSubtitlesItem["Width"].isNull())
+			subtitlesObject.width = std::stol(valueSubtitlesSubtitlesItem["Width"].asString());
+		if(!valueSubtitlesSubtitlesItem["Height"].isNull())
+			subtitlesObject.height = std::stol(valueSubtitlesSubtitlesItem["Height"].asString());
+		subtitles_.push_back(subtitlesObject);
+	}
+	auto allAddressesNode = value["Addresses"]["AddressesItem"];
+	for (auto valueAddressesAddressesItem : allAddressesNode)
+	{
+		AddressesItem addressesObject;
+		if(!valueAddressesAddressesItem["Language"].isNull())
+			addressesObject.language = valueAddressesAddressesItem["Language"].asString();
+		if(!valueAddressesAddressesItem["AddressLine"].isNull())
+			addressesObject.addressLine = valueAddressesAddressesItem["AddressLine"].asString();
+		if(!valueAddressesAddressesItem["Country"].isNull())
+			addressesObject.country = valueAddressesAddressesItem["Country"].asString();
+		if(!valueAddressesAddressesItem["Province"].isNull())
+			addressesObject.province = valueAddressesAddressesItem["Province"].asString();
+		if(!valueAddressesAddressesItem["City"].isNull())
+			addressesObject.city = valueAddressesAddressesItem["City"].asString();
+		if(!valueAddressesAddressesItem["District"].isNull())
+			addressesObject.district = valueAddressesAddressesItem["District"].asString();
+		if(!valueAddressesAddressesItem["Township"].isNull())
+			addressesObject.township = valueAddressesAddressesItem["Township"].asString();
+		addresses_.push_back(addressesObject);
+	}
+	if(!value["Language"].isNull())
+		language_ = value["Language"].asString();
+	if(!value["Title"].isNull())
+		title_ = value["Title"].asString();
+	if(!value["StreamCount"].isNull())
+		streamCount_ = std::stol(value["StreamCount"].asString());
+	if(!value["ProgramCount"].isNull())
+		programCount_ = std::stol(value["ProgramCount"].asString());
+	if(!value["FormatName"].isNull())
+		formatName_ = value["FormatName"].asString();
+	if(!value["FormatLongName"].isNull())
+		formatLongName_ = value["FormatLongName"].asString();
+	if(!value["Size"].isNull())
+		size_ = std::stol(value["Size"].asString());
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["Bitrate"].isNull())
+		bitrate_ = std::stol(value["Bitrate"].asString());
+	if(!value["Artist"].isNull())
+		artist_ = value["Artist"].asString();
+	if(!value["AlbumArtist"].isNull())
+		albumArtist_ = value["AlbumArtist"].asString();
+	if(!value["Composer"].isNull())
+		composer_ = value["Composer"].asString();
+	if(!value["Performer"].isNull())
+		performer_ = value["Performer"].asString();
+	if(!value["Album"].isNull())
+		album_ = value["Album"].asString();
+	if(!value["Duration"].isNull())
+		duration_ = value["Duration"].asString();
+	if(!value["ProduceTime"].isNull())
+		produceTime_ = value["ProduceTime"].asString();
+	if(!value["LatLong"].isNull())
+		latLong_ = value["LatLong"].asString();
+	if(!value["VideoWidth"].isNull())
+		videoWidth_ = std::stol(value["VideoWidth"].asString());
+	if(!value["VideoHeight"].isNull())
+		videoHeight_ = std::stol(value["VideoHeight"].asString());
+
+}
+
+std::string DetectMediaMetaResult::getArtist()const
+{
+	return artist_;
+}
+
+std::string DetectMediaMetaResult::getProduceTime()const
+{
+	return produceTime_;
+}
+
+std::string DetectMediaMetaResult::getComposer()const
+{
+	return composer_;
+}
+
+std::vector<DetectMediaMetaResult::VideoStreamsItem> DetectMediaMetaResult::getVideoStreams()const
+{
+	return videoStreams_;
+}
+
+long DetectMediaMetaResult::getSize()const
+{
+	return size_;
+}
+
+long DetectMediaMetaResult::getVideoWidth()const
+{
+	return videoWidth_;
+}
+
+std::string DetectMediaMetaResult::getFormatLongName()const
+{
+	return formatLongName_;
+}
+
+long DetectMediaMetaResult::getProgramCount()const
+{
+	return programCount_;
+}
+
+double DetectMediaMetaResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DetectMediaMetaResult::getTitle()const
+{
+	return title_;
+}
+
+std::string DetectMediaMetaResult::getAlbum()const
+{
+	return album_;
+}
+
+double DetectMediaMetaResult::getDuration()const
+{
+	return duration_;
+}
+
+long DetectMediaMetaResult::getBitrate()const
+{
+	return bitrate_;
+}
+
+std::string DetectMediaMetaResult::getAlbumArtist()const
+{
+	return albumArtist_;
+}
+
+std::vector<DetectMediaMetaResult::AudioStreamsItem> DetectMediaMetaResult::getAudioStreams()const
+{
+	return audioStreams_;
+}
+
+std::vector<DetectMediaMetaResult::AddressesItem> DetectMediaMetaResult::getAddresses()const
+{
+	return addresses_;
+}
+
+long DetectMediaMetaResult::getStreamCount()const
+{
+	return streamCount_;
+}
+
+std::string DetectMediaMetaResult::getPerformer()const
+{
+	return performer_;
+}
+
+std::string DetectMediaMetaResult::getLanguage()const
+{
+	return language_;
+}
+
+long DetectMediaMetaResult::getVideoHeight()const
+{
+	return videoHeight_;
+}
+
+std::vector<DetectMediaMetaResult::SubtitlesItem> DetectMediaMetaResult::getSubtitles()const
+{
+	return subtitles_;
+}
+
+std::string DetectMediaMetaResult::getFormatName()const
+{
+	return formatName_;
+}
+
+std::string DetectMediaMetaResult::getLatLong()const
+{
+	return latLong_;
+}
+

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

@@ -25,15 +25,6 @@ DetectTextAnomalyRequest::DetectTextAnomalyRequest()
 
 DetectTextAnomalyRequest::~DetectTextAnomalyRequest() {}
 
-std::string DetectTextAnomalyRequest::getProjectName() const {
-  return projectName_;
-}
-
-void DetectTextAnomalyRequest::setProjectName(const std::string &projectName) {
-  projectName_ = projectName;
-  setParameter(std::string("ProjectName"), projectName);
-}
-
 std::string DetectTextAnomalyRequest::getContent() const {
   return content_;
 }
@@ -43,3 +34,12 @@ void DetectTextAnomalyRequest::setContent(const std::string &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/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/ExtractDocumentTextRequest.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/ExtractDocumentTextRequest.h>
+
+using AlibabaCloud::Imm::Model::ExtractDocumentTextRequest;
+
+ExtractDocumentTextRequest::ExtractDocumentTextRequest()
+    : RpcServiceRequest("imm", "2020-09-30", "ExtractDocumentText") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ExtractDocumentTextRequest::~ExtractDocumentTextRequest() {}
+
+std::string ExtractDocumentTextRequest::getProjectName() const {
+  return projectName_;
+}
+
+void ExtractDocumentTextRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
+}
+
+ExtractDocumentTextRequest::CredentialConfig ExtractDocumentTextRequest::getCredentialConfig() const {
+  return credentialConfig_;
+}
+
+void ExtractDocumentTextRequest::setCredentialConfig(const ExtractDocumentTextRequest::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 ExtractDocumentTextRequest::getSourceURI() const {
+  return sourceURI_;
+}
+
+void ExtractDocumentTextRequest::setSourceURI(const std::string &sourceURI) {
+  sourceURI_ = sourceURI;
+  setParameter(std::string("SourceURI"), sourceURI);
+}
+

imm/src/model/ExtractDocumentTextResult.cc

@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/imm/model/MergeFigureClustersResult.h>
+#include <alibabacloud/imm/model/ExtractDocumentTextResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Imm;
 using namespace AlibabaCloud::Imm::Model;
 
-MergeFigureClustersResult::MergeFigureClustersResult() :
+ExtractDocumentTextResult::ExtractDocumentTextResult() :
 	ServiceResult()
 {}
 
-MergeFigureClustersResult::MergeFigureClustersResult(const std::string &payload) :
+ExtractDocumentTextResult::ExtractDocumentTextResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-MergeFigureClustersResult::~MergeFigureClustersResult()
+ExtractDocumentTextResult::~ExtractDocumentTextResult()
 {}
 
-void MergeFigureClustersResult::parse(const std::string &payload)
+void ExtractDocumentTextResult::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["DocumentText"].isNull())
+		documentText_ = value["DocumentText"].asString();
 
 }
 
-std::string MergeFigureClustersResult::getTaskId()const
+std::string ExtractDocumentTextResult::getDocumentText()const
 {
-	return taskId_;
+	return documentText_;
 }
 

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);
-}
-