Support desktop group auto scale.

ecd/src/model/AddDevicesRequest.cc

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/AddDevicesRequest.h>
+
+using AlibabaCloud::Ecd::Model::AddDevicesRequest;
+
+AddDevicesRequest::AddDevicesRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "AddDevices") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddDevicesRequest::~AddDevicesRequest() {}
+
+int AddDevicesRequest::getClientType() const {
+  return clientType_;
+}
+
+void AddDevicesRequest::setClientType(int clientType) {
+  clientType_ = clientType;
+  setParameter(std::string("ClientType"), std::to_string(clientType));
+}
+
+std::vector<std::string> AddDevicesRequest::getDeviceIds() const {
+  return deviceIds_;
+}
+
+void AddDevicesRequest::setDeviceIds(const std::vector<std::string> &deviceIds) {
+  deviceIds_ = deviceIds;
+}
+
+std::string AddDevicesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AddDevicesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ecd/src/model/AddFilePermissionRequest.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/AddFilePermissionRequest.h>
+
+using AlibabaCloud::Ecd::Model::AddFilePermissionRequest;
+
+AddFilePermissionRequest::AddFilePermissionRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "AddFilePermission") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddFilePermissionRequest::~AddFilePermissionRequest() {}
+
+std::vector<AddFilePermissionRequest::MemberList> AddFilePermissionRequest::getMemberList() const {
+  return memberList_;
+}
+
+void AddFilePermissionRequest::setMemberList(const std::vector<AddFilePermissionRequest::MemberList> &memberList) {
+  memberList_ = memberList;
+  for(int dep1 = 0; dep1 != memberList.size(); dep1++) {
+    setParameter(std::string("MemberList") + "." + std::to_string(dep1 + 1) + ".ExpireTime", std::to_string(memberList[dep1].expireTime));
+    setParameter(std::string("MemberList") + "." + std::to_string(dep1 + 1) + ".RoleId", memberList[dep1].roleId);
+    setParameter(std::string("MemberList") + "." + std::to_string(dep1 + 1) + ".CdsIdentity.Id", memberList[dep1].cdsIdentity.id);
+    setParameter(std::string("MemberList") + "." + std::to_string(dep1 + 1) + ".CdsIdentity.Type", memberList[dep1].cdsIdentity.type);
+    setParameter(std::string("MemberList") + "." + std::to_string(dep1 + 1) + ".DisinheritSubGroup", memberList[dep1].disinheritSubGroup ? "true" : "false");
+  }
+}
+
+std::string AddFilePermissionRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void AddFilePermissionRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string AddFilePermissionRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AddFilePermissionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AddFilePermissionRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void AddFilePermissionRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string AddFilePermissionRequest::getFileId() const {
+  return fileId_;
+}
+
+void AddFilePermissionRequest::setFileId(const std::string &fileId) {
+  fileId_ = fileId;
+  setParameter(std::string("FileId"), fileId);
+}
+

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

ecd/src/model/ApplyAutoSnapshotPolicyRequest.cc

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/ApplyAutoSnapshotPolicyRequest.h>
+
+using AlibabaCloud::Ecd::Model::ApplyAutoSnapshotPolicyRequest;
+
+ApplyAutoSnapshotPolicyRequest::ApplyAutoSnapshotPolicyRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ApplyAutoSnapshotPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ApplyAutoSnapshotPolicyRequest::~ApplyAutoSnapshotPolicyRequest() {}
+
+std::string ApplyAutoSnapshotPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void ApplyAutoSnapshotPolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string ApplyAutoSnapshotPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ApplyAutoSnapshotPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> ApplyAutoSnapshotPolicyRequest::getDesktopId() const {
+  return desktopId_;
+}
+
+void ApplyAutoSnapshotPolicyRequest::setDesktopId(const std::vector<std::string> &desktopId) {
+  desktopId_ = desktopId;
+}
+

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

ecd/src/model/AttachEndUserRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/ecd/model/AttachEndUserRequest.h>
+
+using AlibabaCloud::Ecd::Model::AttachEndUserRequest;
+
+AttachEndUserRequest::AttachEndUserRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "AttachEndUser") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AttachEndUserRequest::~AttachEndUserRequest() {}
+
+int AttachEndUserRequest::getClientType() const {
+  return clientType_;
+}
+
+void AttachEndUserRequest::setClientType(int clientType) {
+  clientType_ = clientType;
+  setParameter(std::string("ClientType"), std::to_string(clientType));
+}
+
+std::string AttachEndUserRequest::getUserType() const {
+  return userType_;
+}
+
+void AttachEndUserRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+std::string AttachEndUserRequest::getDeviceId() const {
+  return deviceId_;
+}
+
+void AttachEndUserRequest::setDeviceId(const std::string &deviceId) {
+  deviceId_ = deviceId;
+  setParameter(std::string("DeviceId"), deviceId);
+}
+
+std::string AttachEndUserRequest::getAdDomain() const {
+  return adDomain_;
+}
+
+void AttachEndUserRequest::setAdDomain(const std::string &adDomain) {
+  adDomain_ = adDomain;
+  setParameter(std::string("AdDomain"), adDomain);
+}
+
+std::string AttachEndUserRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AttachEndUserRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AttachEndUserRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void AttachEndUserRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string AttachEndUserRequest::getDirectoryId() const {
+  return directoryId_;
+}
+
+void AttachEndUserRequest::setDirectoryId(const std::string &directoryId) {
+  directoryId_ = directoryId;
+  setParameter(std::string("DirectoryId"), directoryId);
+}
+

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

ecd/src/model/CancelAutoSnapshotPolicyRequest.cc

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/CancelAutoSnapshotPolicyRequest.h>
+
+using AlibabaCloud::Ecd::Model::CancelAutoSnapshotPolicyRequest;
+
+CancelAutoSnapshotPolicyRequest::CancelAutoSnapshotPolicyRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CancelAutoSnapshotPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CancelAutoSnapshotPolicyRequest::~CancelAutoSnapshotPolicyRequest() {}
+
+std::string CancelAutoSnapshotPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void CancelAutoSnapshotPolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string CancelAutoSnapshotPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CancelAutoSnapshotPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> CancelAutoSnapshotPolicyRequest::getDesktopId() const {
+  return desktopId_;
+}
+
+void CancelAutoSnapshotPolicyRequest::setDesktopId(const std::vector<std::string> &desktopId) {
+  desktopId_ = desktopId;
+}
+

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

ecd/src/model/CancelCdsFileShareLinkRequest.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/ecd/model/CancelCdsFileShareLinkRequest.h>
+
+using AlibabaCloud::Ecd::Model::CancelCdsFileShareLinkRequest;
+
+CancelCdsFileShareLinkRequest::CancelCdsFileShareLinkRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CancelCdsFileShareLink") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CancelCdsFileShareLinkRequest::~CancelCdsFileShareLinkRequest() {}
+
+std::string CancelCdsFileShareLinkRequest::getShareId() const {
+  return shareId_;
+}
+
+void CancelCdsFileShareLinkRequest::setShareId(const std::string &shareId) {
+  shareId_ = shareId;
+  setParameter(std::string("ShareId"), shareId);
+}
+
+std::string CancelCdsFileShareLinkRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void CancelCdsFileShareLinkRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+

ecd/src/model/CancelCdsFileShareLinkResult.cc

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

ecd/src/model/CompleteCdsFileRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/CompleteCdsFileRequest.h>
+
+using AlibabaCloud::Ecd::Model::CompleteCdsFileRequest;
+
+CompleteCdsFileRequest::CompleteCdsFileRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CompleteCdsFile") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CompleteCdsFileRequest::~CompleteCdsFileRequest() {}
+
+std::string CompleteCdsFileRequest::getUploadId() const {
+  return uploadId_;
+}
+
+void CompleteCdsFileRequest::setUploadId(const std::string &uploadId) {
+  uploadId_ = uploadId;
+  setParameter(std::string("UploadId"), uploadId);
+}
+
+std::string CompleteCdsFileRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void CompleteCdsFileRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string CompleteCdsFileRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CompleteCdsFileRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CompleteCdsFileRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void CompleteCdsFileRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string CompleteCdsFileRequest::getFileId() const {
+  return fileId_;
+}
+
+void CompleteCdsFileRequest::setFileId(const std::string &fileId) {
+  fileId_ = fileId;
+  setParameter(std::string("FileId"), fileId);
+}
+

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

ecd/src/model/ConfigADConnectorTrustRequest.cc

@@ -52,3 +52,12 @@ void ConfigADConnectorTrustRequest::setRegionId(const std::string &regionId) {
   setParameter(std::string("RegionId"), regionId);
 }
 
+bool ConfigADConnectorTrustRequest::getRdsLicenseDomain() const {
+  return rdsLicenseDomain_;
+}
+
+void ConfigADConnectorTrustRequest::setRdsLicenseDomain(bool rdsLicenseDomain) {
+  rdsLicenseDomain_ = rdsLicenseDomain;
+  setParameter(std::string("RdsLicenseDomain"), rdsLicenseDomain ? "true" : "false");
+}
+

ecd/src/model/CopyCdsFileRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/ecd/model/CopyCdsFileRequest.h>
+
+using AlibabaCloud::Ecd::Model::CopyCdsFileRequest;
+
+CopyCdsFileRequest::CopyCdsFileRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CopyCdsFile") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CopyCdsFileRequest::~CopyCdsFileRequest() {}
+
+bool CopyCdsFileRequest::getAutoRename() const {
+  return autoRename_;
+}
+
+void CopyCdsFileRequest::setAutoRename(bool autoRename) {
+  autoRename_ = autoRename;
+  setParameter(std::string("AutoRename"), autoRename ? "true" : "false");
+}
+
+std::string CopyCdsFileRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void CopyCdsFileRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string CopyCdsFileRequest::getParentFolderId() const {
+  return parentFolderId_;
+}
+
+void CopyCdsFileRequest::setParentFolderId(const std::string &parentFolderId) {
+  parentFolderId_ = parentFolderId;
+  setParameter(std::string("ParentFolderId"), parentFolderId);
+}
+
+std::string CopyCdsFileRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CopyCdsFileRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CopyCdsFileRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void CopyCdsFileRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string CopyCdsFileRequest::getFileId() const {
+  return fileId_;
+}
+
+void CopyCdsFileRequest::setFileId(const std::string &fileId) {
+  fileId_ = fileId;
+  setParameter(std::string("FileId"), fileId);
+}
+

ecd/src/model/CopyCdsFileResult.cc

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/CopyCdsFileResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+CopyCdsFileResult::CopyCdsFileResult() :
+	ServiceResult()
+{}
+
+CopyCdsFileResult::CopyCdsFileResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CopyCdsFileResult::~CopyCdsFileResult()
+{}
+
+void CopyCdsFileResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto copyCdsFileModelNode = value["CopyCdsFileModel"];
+	if(!copyCdsFileModelNode["AsyncTaskId"].isNull())
+		copyCdsFileModel_.asyncTaskId = copyCdsFileModelNode["AsyncTaskId"].asString();
+	if(!copyCdsFileModelNode["FileId"].isNull())
+		copyCdsFileModel_.fileId = copyCdsFileModelNode["FileId"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString();
+
+}
+
+std::string CopyCdsFileResult::getMessage()const
+{
+	return message_;
+}
+
+CopyCdsFileResult::CopyCdsFileModel CopyCdsFileResult::getCopyCdsFileModel()const
+{
+	return copyCdsFileModel_;
+}
+
+std::string CopyCdsFileResult::getCode()const
+{
+	return code_;
+}
+
+std::string CopyCdsFileResult::getSuccess()const
+{
+	return success_;
+}
+

ecd/src/model/CreateAutoSnapshotPolicyRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/CreateAutoSnapshotPolicyRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateAutoSnapshotPolicyRequest;
+
+CreateAutoSnapshotPolicyRequest::CreateAutoSnapshotPolicyRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateAutoSnapshotPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateAutoSnapshotPolicyRequest::~CreateAutoSnapshotPolicyRequest() {}
+
+std::string CreateAutoSnapshotPolicyRequest::getCronExpression() const {
+  return cronExpression_;
+}
+
+void CreateAutoSnapshotPolicyRequest::setCronExpression(const std::string &cronExpression) {
+  cronExpression_ = cronExpression;
+  setParameter(std::string("CronExpression"), cronExpression);
+}
+
+std::string CreateAutoSnapshotPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateAutoSnapshotPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateAutoSnapshotPolicyRequest::getPolicyName() const {
+  return policyName_;
+}
+
+void CreateAutoSnapshotPolicyRequest::setPolicyName(const std::string &policyName) {
+  policyName_ = policyName;
+  setParameter(std::string("PolicyName"), policyName);
+}
+
+int CreateAutoSnapshotPolicyRequest::getRetentionDays() const {
+  return retentionDays_;
+}
+
+void CreateAutoSnapshotPolicyRequest::setRetentionDays(int retentionDays) {
+  retentionDays_ = retentionDays;
+  setParameter(std::string("RetentionDays"), std::to_string(retentionDays));
+}
+

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

ecd/src/model/CreateCdsFileRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/CreateCdsFileRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateCdsFileRequest;
+
+CreateCdsFileRequest::CreateCdsFileRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateCdsFile") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateCdsFileRequest::~CreateCdsFileRequest() {}
+
+std::string CreateCdsFileRequest::getFileType() const {
+  return fileType_;
+}
+
+void CreateCdsFileRequest::setFileType(const std::string &fileType) {
+  fileType_ = fileType;
+  setParameter(std::string("FileType"), fileType);
+}
+
+std::string CreateCdsFileRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void CreateCdsFileRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string CreateCdsFileRequest::getConflictPolicy() const {
+  return conflictPolicy_;
+}
+
+void CreateCdsFileRequest::setConflictPolicy(const std::string &conflictPolicy) {
+  conflictPolicy_ = conflictPolicy;
+  setParameter(std::string("ConflictPolicy"), conflictPolicy);
+}
+
+std::string CreateCdsFileRequest::getParentFileId() const {
+  return parentFileId_;
+}
+
+void CreateCdsFileRequest::setParentFileId(const std::string &parentFileId) {
+  parentFileId_ = parentFileId;
+  setParameter(std::string("ParentFileId"), parentFileId);
+}
+
+std::string CreateCdsFileRequest::getFileName() const {
+  return fileName_;
+}
+
+void CreateCdsFileRequest::setFileName(const std::string &fileName) {
+  fileName_ = fileName;
+  setParameter(std::string("FileName"), fileName);
+}
+
+std::string CreateCdsFileRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateCdsFileRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+long CreateCdsFileRequest::getFileLength() const {
+  return fileLength_;
+}
+
+void CreateCdsFileRequest::setFileLength(long fileLength) {
+  fileLength_ = fileLength;
+  setParameter(std::string("FileLength"), std::to_string(fileLength));
+}
+
+std::string CreateCdsFileRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void CreateCdsFileRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string CreateCdsFileRequest::getFileHash() const {
+  return fileHash_;
+}
+
+void CreateCdsFileRequest::setFileHash(const std::string &fileHash) {
+  fileHash_ = fileHash;
+  setParameter(std::string("FileHash"), fileHash);
+}
+

ecd/src/model/CreateCdsFileResult.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/ecd/model/CreateCdsFileResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+CreateCdsFileResult::CreateCdsFileResult() :
+	ServiceResult()
+{}
+
+CreateCdsFileResult::CreateCdsFileResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateCdsFileResult::~CreateCdsFileResult()
+{}
+
+void CreateCdsFileResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto fileModelNode = value["FileModel"];
+	if(!fileModelNode["UploadUrl"].isNull())
+		fileModel_.uploadUrl = fileModelNode["UploadUrl"].asString();
+	if(!fileModelNode["FileId"].isNull())
+		fileModel_.fileId = fileModelNode["FileId"].asString();
+	if(!fileModelNode["UploadId"].isNull())
+		fileModel_.uploadId = fileModelNode["UploadId"].asString();
+
+}
+
+CreateCdsFileResult::FileModel CreateCdsFileResult::getFileModel()const
+{
+	return fileModel_;
+}
+

ecd/src/model/CreateCdsFileShareLinkRequest.cc

@@ -0,0 +1,143 @@
+/*
+ * 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/ecd/model/CreateCdsFileShareLinkRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateCdsFileShareLinkRequest;
+
+CreateCdsFileShareLinkRequest::CreateCdsFileShareLinkRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateCdsFileShareLink") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateCdsFileShareLinkRequest::~CreateCdsFileShareLinkRequest() {}
+
+std::string CreateCdsFileShareLinkRequest::getDescription() const {
+  return description_;
+}
+
+void CreateCdsFileShareLinkRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+long CreateCdsFileShareLinkRequest::getPreviewLimit() const {
+  return previewLimit_;
+}
+
+void CreateCdsFileShareLinkRequest::setPreviewLimit(long previewLimit) {
+  previewLimit_ = previewLimit;
+  setParameter(std::string("PreviewLimit"), std::to_string(previewLimit));
+}
+
+bool CreateCdsFileShareLinkRequest::getDisableDownload() const {
+  return disableDownload_;
+}
+
+void CreateCdsFileShareLinkRequest::setDisableDownload(bool disableDownload) {
+  disableDownload_ = disableDownload;
+  setParameter(std::string("DisableDownload"), disableDownload ? "true" : "false");
+}
+
+bool CreateCdsFileShareLinkRequest::getDisablePreview() const {
+  return disablePreview_;
+}
+
+void CreateCdsFileShareLinkRequest::setDisablePreview(bool disablePreview) {
+  disablePreview_ = disablePreview;
+  setParameter(std::string("DisablePreview"), disablePreview ? "true" : "false");
+}
+
+std::string CreateCdsFileShareLinkRequest::getSharePwd() const {
+  return sharePwd_;
+}
+
+void CreateCdsFileShareLinkRequest::setSharePwd(const std::string &sharePwd) {
+  sharePwd_ = sharePwd;
+  setParameter(std::string("SharePwd"), sharePwd);
+}
+
+std::string CreateCdsFileShareLinkRequest::getShareName() const {
+  return shareName_;
+}
+
+void CreateCdsFileShareLinkRequest::setShareName(const std::string &shareName) {
+  shareName_ = shareName;
+  setParameter(std::string("ShareName"), shareName);
+}
+
+std::string CreateCdsFileShareLinkRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void CreateCdsFileShareLinkRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+bool CreateCdsFileShareLinkRequest::getDisableSave() const {
+  return disableSave_;
+}
+
+void CreateCdsFileShareLinkRequest::setDisableSave(bool disableSave) {
+  disableSave_ = disableSave;
+  setParameter(std::string("DisableSave"), disableSave ? "true" : "false");
+}
+
+long CreateCdsFileShareLinkRequest::getDownloadLimit() const {
+  return downloadLimit_;
+}
+
+void CreateCdsFileShareLinkRequest::setDownloadLimit(long downloadLimit) {
+  downloadLimit_ = downloadLimit;
+  setParameter(std::string("DownloadLimit"), std::to_string(downloadLimit));
+}
+
+std::string CreateCdsFileShareLinkRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void CreateCdsFileShareLinkRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+long CreateCdsFileShareLinkRequest::getSaveLimit() const {
+  return saveLimit_;
+}
+
+void CreateCdsFileShareLinkRequest::setSaveLimit(long saveLimit) {
+  saveLimit_ = saveLimit;
+  setParameter(std::string("SaveLimit"), std::to_string(saveLimit));
+}
+
+std::vector<std::string> CreateCdsFileShareLinkRequest::getFileIds() const {
+  return fileIds_;
+}
+
+void CreateCdsFileShareLinkRequest::setFileIds(const std::vector<std::string> &fileIds) {
+  fileIds_ = fileIds;
+}
+
+std::string CreateCdsFileShareLinkRequest::getExpiration() const {
+  return expiration_;
+}
+
+void CreateCdsFileShareLinkRequest::setExpiration(const std::string &expiration) {
+  expiration_ = expiration;
+  setParameter(std::string("Expiration"), expiration);
+}
+

ecd/src/model/CreateCdsFileShareLinkResult.cc

@@ -0,0 +1,121 @@
+/*
+ * 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/ecd/model/CreateCdsFileShareLinkResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+CreateCdsFileShareLinkResult::CreateCdsFileShareLinkResult() :
+	ServiceResult()
+{}
+
+CreateCdsFileShareLinkResult::CreateCdsFileShareLinkResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateCdsFileShareLinkResult::~CreateCdsFileShareLinkResult()
+{}
+
+void CreateCdsFileShareLinkResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Description"].isNull())
+		data_.description = dataNode["Description"].asString();
+	if(!dataNode["SaveLimit"].isNull())
+		data_.saveLimit = std::stol(dataNode["SaveLimit"].asString());
+	if(!dataNode["DownloadCount"].isNull())
+		data_.downloadCount = std::stol(dataNode["DownloadCount"].asString());
+	if(!dataNode["Creator"].isNull())
+		data_.creator = dataNode["Creator"].asString();
+	if(!dataNode["SaveCount"].isNull())
+		data_.saveCount = std::stol(dataNode["SaveCount"].asString());
+	if(!dataNode["DisableSave"].isNull())
+		data_.disableSave = dataNode["DisableSave"].asString() == "true";
+	if(!dataNode["SharePwd"].isNull())
+		data_.sharePwd = dataNode["SharePwd"].asString();
+	if(!dataNode["DisablePreview"].isNull())
+		data_.disablePreview = dataNode["DisablePreview"].asString() == "true";
+	if(!dataNode["AccessCount"].isNull())
+		data_.accessCount = std::stol(dataNode["AccessCount"].asString());
+	if(!dataNode["ShareId"].isNull())
+		data_.shareId = dataNode["ShareId"].asString();
+	if(!dataNode["DownloadLimit"].isNull())
+		data_.downloadLimit = std::stol(dataNode["DownloadLimit"].asString());
+	if(!dataNode["Status"].isNull())
+		data_.status = dataNode["Status"].asString();
+	if(!dataNode["DriveId"].isNull())
+		data_.driveId = dataNode["DriveId"].asString();
+	if(!dataNode["ModifiyTime"].isNull())
+		data_.modifiyTime = dataNode["ModifiyTime"].asString();
+	if(!dataNode["DisableDownload"].isNull())
+		data_.disableDownload = dataNode["DisableDownload"].asString() == "true";
+	if(!dataNode["Expiration"].isNull())
+		data_.expiration = dataNode["Expiration"].asString();
+	if(!dataNode["Expired"].isNull())
+		data_.expired = dataNode["Expired"].asString() == "true";
+	if(!dataNode["PreviewCount"].isNull())
+		data_.previewCount = std::stol(dataNode["PreviewCount"].asString());
+	if(!dataNode["PreviewLimit"].isNull())
+		data_.previewLimit = std::stol(dataNode["PreviewLimit"].asString());
+	if(!dataNode["VideoPreviewCount"].isNull())
+		data_.videoPreviewCount = std::stol(dataNode["VideoPreviewCount"].asString());
+	if(!dataNode["ReportCount"].isNull())
+		data_.reportCount = std::stol(dataNode["ReportCount"].asString());
+	if(!dataNode["FileIds"].isNull())
+		data_.fileIds = dataNode["FileIds"].asString();
+	if(!dataNode["ShareName"].isNull())
+		data_.shareName = dataNode["ShareName"].asString();
+	if(!dataNode["CreateTime"].isNull())
+		data_.createTime = dataNode["CreateTime"].asString();
+	if(!dataNode["ShareLink"].isNull())
+		data_.shareLink = dataNode["ShareLink"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string CreateCdsFileShareLinkResult::getMessage()const
+{
+	return message_;
+}
+
+CreateCdsFileShareLinkResult::Data CreateCdsFileShareLinkResult::getData()const
+{
+	return data_;
+}
+
+std::string CreateCdsFileShareLinkResult::getCode()const
+{
+	return code_;
+}
+
+bool CreateCdsFileShareLinkResult::getSuccess()const
+{
+	return success_;
+}
+

ecd/src/model/CreateDesktopGroupRequest.cc

@@ -43,6 +43,15 @@ void CreateDesktopGroupRequest::setAllowBufferCount(int allowBufferCount) {
   setParameter(std::string("AllowBufferCount"), std::to_string(allowBufferCount));
 }
 
+int CreateDesktopGroupRequest::getGroupVersion() const {
+  return groupVersion_;
+}
+
+void CreateDesktopGroupRequest::setGroupVersion(int groupVersion) {
+  groupVersion_ = groupVersion;
+  setParameter(std::string("GroupVersion"), std::to_string(groupVersion));
+}
+
 bool CreateDesktopGroupRequest::getAllClassifyUsers() const {
   return allClassifyUsers_;
 }
@@ -124,6 +133,15 @@ void CreateDesktopGroupRequest::setPeriodUnit(const std::string &periodUnit) {
   setParameter(std::string("PeriodUnit"), periodUnit);
 }
 
+bool CreateDesktopGroupRequest::getAutoRenew() const {
+  return autoRenew_;
+}
+
+void CreateDesktopGroupRequest::setAutoRenew(bool autoRenew) {
+  autoRenew_ = autoRenew;
+  setParameter(std::string("AutoRenew"), autoRenew ? "true" : "false");
+}
+
 bool CreateDesktopGroupRequest::getProfileFollowSwitch() const {
   return profileFollowSwitch_;
 }
@@ -133,6 +151,15 @@ void CreateDesktopGroupRequest::setProfileFollowSwitch(bool profileFollowSwitch)
   setParameter(std::string("ProfileFollowSwitch"), profileFollowSwitch ? "true" : "false");
 }
 
+int CreateDesktopGroupRequest::getBuyDesktopsCount() const {
+  return buyDesktopsCount_;
+}
+
+void CreateDesktopGroupRequest::setBuyDesktopsCount(int buyDesktopsCount) {
+  buyDesktopsCount_ = buyDesktopsCount;
+  setParameter(std::string("BuyDesktopsCount"), std::to_string(buyDesktopsCount));
+}
+
 std::string CreateDesktopGroupRequest::getPolicyGroupId() const {
   return policyGroupId_;
 }

ecd/src/model/CreateDesktopsRequest.cc

@@ -79,6 +79,25 @@ void CreateDesktopsRequest::setHostname(const std::string &hostname) {
   setParameter(std::string("Hostname"), hostname);
 }
 
+std::vector<CreateDesktopsRequest::DesktopTimers> CreateDesktopsRequest::getDesktopTimers() const {
+  return desktopTimers_;
+}
+
+void CreateDesktopsRequest::setDesktopTimers(const std::vector<CreateDesktopsRequest::DesktopTimers> &desktopTimers) {
+  desktopTimers_ = desktopTimers;
+  for(int dep1 = 0; dep1 != desktopTimers.size(); dep1++) {
+  auto desktopTimersObj = desktopTimers.at(dep1);
+  std::string desktopTimersObjStr = std::string("DesktopTimers") + "." + std::to_string(dep1 + 1);
+    setParameter(desktopTimersObjStr + ".CronExpression", desktopTimersObj.cronExpression);
+    setParameter(desktopTimersObjStr + ".TimerType", desktopTimersObj.timerType);
+    setParameter(desktopTimersObjStr + ".AllowClientSetting", desktopTimersObj.allowClientSetting ? "true" : "false");
+    setParameter(desktopTimersObjStr + ".ResetType", desktopTimersObj.resetType);
+    setParameter(desktopTimersObjStr + ".Enforce", desktopTimersObj.enforce ? "true" : "false");
+    setParameter(desktopTimersObjStr + ".Interval", std::to_string(desktopTimersObj.interval));
+    setParameter(desktopTimersObjStr + ".OperationType", desktopTimersObj.operationType);
+  }
+}
+
 std::string CreateDesktopsRequest::getRegionId() const {
   return regionId_;
 }
@@ -123,6 +142,15 @@ void CreateDesktopsRequest::setEndUserId(const std::vector<std::string> &endUser
   endUserId_ = endUserId;
 }
 
+std::string CreateDesktopsRequest::getDesktopMemberIp() const {
+  return desktopMemberIp_;
+}
+
+void CreateDesktopsRequest::setDesktopMemberIp(const std::string &desktopMemberIp) {
+  desktopMemberIp_ = desktopMemberIp;
+  setParameter(std::string("DesktopMemberIp"), desktopMemberIp);
+}
+
 std::vector<CreateDesktopsRequest::Tag> CreateDesktopsRequest::getTag() const {
   return tag_;
 }
@@ -137,6 +165,24 @@ void CreateDesktopsRequest::setTag(const std::vector<CreateDesktopsRequest::Tag>
   }
 }
 
+std::vector<CreateDesktopsRequest::BundleModels> CreateDesktopsRequest::getBundleModels() const {
+  return bundleModels_;
+}
+
+void CreateDesktopsRequest::setBundleModels(const std::vector<CreateDesktopsRequest::BundleModels> &bundleModels) {
+  bundleModels_ = bundleModels;
+  for(int dep1 = 0; dep1 != bundleModels.size(); dep1++) {
+  auto bundleModelsObj = bundleModels.at(dep1);
+  std::string bundleModelsObjStr = std::string("BundleModels") + "." + std::to_string(dep1 + 1);
+    setParameter(bundleModelsObjStr + ".VolumeEncryptionEnabled", bundleModelsObj.volumeEncryptionEnabled ? "true" : "false");
+    setParameter(bundleModelsObjStr + ".VolumeEncryptionKey", bundleModelsObj.volumeEncryptionKey);
+    setParameter(bundleModelsObjStr + ".Amount", std::to_string(bundleModelsObj.amount));
+    setParameter(bundleModelsObjStr + ".DesktopName", bundleModelsObj.desktopName);
+    setParameter(bundleModelsObjStr + ".Hostname", bundleModelsObj.hostname);
+    setParameter(bundleModelsObjStr + ".BundleId", bundleModelsObj.bundleId);
+  }
+}
+
 bool CreateDesktopsRequest::getVolumeEncryptionEnabled() const {
   return volumeEncryptionEnabled_;
 }

ecd/src/model/CreateDriveRequest.cc

@@ -1,135 +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/ecd/model/CreateDriveRequest.h>
-
-using AlibabaCloud::Ecd::Model::CreateDriveRequest;
-
-CreateDriveRequest::CreateDriveRequest()
-    : RpcServiceRequest("ecd", "2020-09-30", "CreateDrive") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateDriveRequest::~CreateDriveRequest() {}
-
-bool CreateDriveRequest::getProfileRoaming() const {
-  return profileRoaming_;
-}
-
-void CreateDriveRequest::setProfileRoaming(bool profileRoaming) {
-  profileRoaming_ = profileRoaming;
-  setParameter(std::string("ProfileRoaming"), profileRoaming ? "true" : "false");
-}
-
-std::string CreateDriveRequest::getDescription() const {
-  return description_;
-}
-
-void CreateDriveRequest::setDescription(const std::string &description) {
-  description_ = description;
-  setParameter(std::string("Description"), description);
-}
-
-std::string CreateDriveRequest::getType() const {
-  return type_;
-}
-
-void CreateDriveRequest::setType(const std::string &type) {
-  type_ = type;
-  setParameter(std::string("Type"), type);
-}
-
-std::string CreateDriveRequest::getUserId() const {
-  return userId_;
-}
-
-void CreateDriveRequest::setUserId(const std::string &userId) {
-  userId_ = userId;
-  setParameter(std::string("UserId"), userId);
-}
-
-std::string CreateDriveRequest::getDomainId() const {
-  return domainId_;
-}
-
-void CreateDriveRequest::setDomainId(const std::string &domainId) {
-  domainId_ = domainId;
-  setParameter(std::string("DomainId"), domainId);
-}
-
-std::string CreateDriveRequest::getRegionId() const {
-  return regionId_;
-}
-
-void CreateDriveRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
-std::string CreateDriveRequest::getExternalDomainId() const {
-  return externalDomainId_;
-}
-
-void CreateDriveRequest::setExternalDomainId(const std::string &externalDomainId) {
-  externalDomainId_ = externalDomainId;
-  setParameter(std::string("ExternalDomainId"), externalDomainId);
-}
-
-long CreateDriveRequest::getUsedSize() const {
-  return usedSize_;
-}
-
-void CreateDriveRequest::setUsedSize(long usedSize) {
-  usedSize_ = usedSize;
-  setParameter(std::string("UsedSize"), std::to_string(usedSize));
-}
-
-long CreateDriveRequest::getAliUid() const {
-  return aliUid_;
-}
-
-void CreateDriveRequest::setAliUid(long aliUid) {
-  aliUid_ = aliUid;
-  setParameter(std::string("AliUid"), std::to_string(aliUid));
-}
-
-std::string CreateDriveRequest::getDriveName() const {
-  return driveName_;
-}
-
-void CreateDriveRequest::setDriveName(const std::string &driveName) {
-  driveName_ = driveName;
-  setParameter(std::string("DriveName"), driveName);
-}
-
-long CreateDriveRequest::getTotalSize() const {
-  return totalSize_;
-}
-
-void CreateDriveRequest::setTotalSize(long totalSize) {
-  totalSize_ = totalSize;
-  setParameter(std::string("TotalSize"), std::to_string(totalSize));
-}
-
-std::string CreateDriveRequest::getResourceType() const {
-  return resourceType_;
-}
-
-void CreateDriveRequest::setResourceType(const std::string &resourceType) {
-  resourceType_ = resourceType;
-  setParameter(std::string("ResourceType"), resourceType);
-}
-

ecd/src/model/CreateDriveResult.cc

@@ -1,103 +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/ecd/model/CreateDriveResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ecd;
-using namespace AlibabaCloud::Ecd::Model;
-
-CreateDriveResult::CreateDriveResult() :
-	ServiceResult()
-{}
-
-CreateDriveResult::CreateDriveResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-CreateDriveResult::~CreateDriveResult()
-{}
-
-void CreateDriveResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto driveNode = value["Drive"];
-	if(!driveNode["Id"].isNull())
-		drive_.id = driveNode["Id"].asString();
-	if(!driveNode["GmtCreate"].isNull())
-		drive_.gmtCreate = driveNode["GmtCreate"].asString();
-	if(!driveNode["GmtModified"].isNull())
-		drive_.gmtModified = driveNode["GmtModified"].asString();
-	if(!driveNode["AliUid"].isNull())
-		drive_.aliUid = driveNode["AliUid"].asString();
-	if(!driveNode["DomainId"].isNull())
-		drive_.domainId = driveNode["DomainId"].asString();
-	if(!driveNode["DriveId"].isNull())
-		drive_.driveId = driveNode["DriveId"].asString();
-	if(!driveNode["ExternalDriveId"].isNull())
-		drive_.externalDriveId = driveNode["ExternalDriveId"].asString();
-	if(!driveNode["UserId"].isNull())
-		drive_.userId = driveNode["UserId"].asString();
-	if(!driveNode["ExternalUserId"].isNull())
-		drive_.externalUserId = driveNode["ExternalUserId"].asString();
-	if(!driveNode["Name"].isNull())
-		drive_.name = driveNode["Name"].asString();
-	if(!driveNode["Description"].isNull())
-		drive_.description = driveNode["Description"].asString();
-	if(!driveNode["TotalSize"].isNull())
-		drive_.totalSize = std::stol(driveNode["TotalSize"].asString());
-	if(!driveNode["UsedSize"].isNull())
-		drive_.usedSize = std::stol(driveNode["UsedSize"].asString());
-	if(!driveNode["Status"].isNull())
-		drive_.status = driveNode["Status"].asString();
-	if(!driveNode["Type"].isNull())
-		drive_.type = driveNode["Type"].asString();
-	if(!driveNode["ProfileRoaming"].isNull())
-		drive_.profileRoaming = driveNode["ProfileRoaming"].asString() == "true";
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-
-}
-
-std::string CreateDriveResult::getMessage()const
-{
-	return message_;
-}
-
-CreateDriveResult::Drive CreateDriveResult::getDrive()const
-{
-	return drive_;
-}
-
-std::string CreateDriveResult::getCode()const
-{
-	return code_;
-}
-
-bool CreateDriveResult::getSuccess()const
-{
-	return success_;
-}
-

ecd/src/model/CreateNetworkPackageRequest.cc

@@ -34,6 +34,15 @@ void CreateNetworkPackageRequest::setOfficeSiteId(const std::string &officeSiteI
   setParameter(std::string("OfficeSiteId"), officeSiteId);
 }
 
+std::string CreateNetworkPackageRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateNetworkPackageRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
 int CreateNetworkPackageRequest::getPeriod() const {
   return period_;
 }
@@ -88,15 +97,6 @@ void CreateNetworkPackageRequest::setAutoRenew(bool autoRenew) {
   setParameter(std::string("AutoRenew"), autoRenew ? "true" : "false");
 }
 
-std::string CreateNetworkPackageRequest::getRegionId() const {
-  return regionId_;
-}
-
-void CreateNetworkPackageRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
 std::string CreateNetworkPackageRequest::getInternetChargeType() const {
   return internetChargeType_;
 }
@@ -106,3 +106,12 @@ void CreateNetworkPackageRequest::setInternetChargeType(const std::string &inter
   setParameter(std::string("InternetChargeType"), internetChargeType);
 }
 
+std::string CreateNetworkPackageRequest::getPayType() const {
+  return payType_;
+}
+
+void CreateNetworkPackageRequest::setPayType(const std::string &payType) {
+  payType_ = payType;
+  setParameter(std::string("PayType"), payType);
+}
+

ecd/src/model/CreatePolicyGroupRequest.cc

@@ -25,24 +25,6 @@ CreatePolicyGroupRequest::CreatePolicyGroupRequest()
 
 CreatePolicyGroupRequest::~CreatePolicyGroupRequest() {}
 
-std::string CreatePolicyGroupRequest::getWatermarkCustomText() const {
-  return watermarkCustomText_;
-}
-
-void CreatePolicyGroupRequest::setWatermarkCustomText(const std::string &watermarkCustomText) {
-  watermarkCustomText_ = watermarkCustomText;
-  setParameter(std::string("WatermarkCustomText"), watermarkCustomText);
-}
-
-std::string CreatePolicyGroupRequest::getPreemptLogin() const {
-  return preemptLogin_;
-}
-
-void CreatePolicyGroupRequest::setPreemptLogin(const std::string &preemptLogin) {
-  preemptLogin_ = preemptLogin;
-  setParameter(std::string("PreemptLogin"), preemptLogin);
-}
-
 long CreatePolicyGroupRequest::getRecordingExpires() const {
   return recordingExpires_;
 }
@@ -52,39 +34,6 @@ void CreatePolicyGroupRequest::setRecordingExpires(long recordingExpires) {
   setParameter(std::string("RecordingExpires"), std::to_string(recordingExpires));
 }
 
-std::vector<CreatePolicyGroupRequest::ClientType> CreatePolicyGroupRequest::getClientType() const {
-  return clientType_;
-}
-
-void CreatePolicyGroupRequest::setClientType(const std::vector<CreatePolicyGroupRequest::ClientType> &clientType) {
-  clientType_ = clientType;
-  for(int dep1 = 0; dep1 != clientType.size(); dep1++) {
-  auto clientTypeObj = clientType.at(dep1);
-  std::string clientTypeObjStr = std::string("ClientType") + "." + std::to_string(dep1 + 1);
-    setParameter(clientTypeObjStr + ".ClientType", clientTypeObj.clientType);
-    setParameter(clientTypeObjStr + ".Status", clientTypeObj.status);
-  }
-}
-
-std::vector<CreatePolicyGroupRequest::UsbSupplyRedirectRule> CreatePolicyGroupRequest::getUsbSupplyRedirectRule() const {
-  return usbSupplyRedirectRule_;
-}
-
-void CreatePolicyGroupRequest::setUsbSupplyRedirectRule(const std::vector<CreatePolicyGroupRequest::UsbSupplyRedirectRule> &usbSupplyRedirectRule) {
-  usbSupplyRedirectRule_ = usbSupplyRedirectRule;
-  for(int dep1 = 0; dep1 != usbSupplyRedirectRule.size(); dep1++) {
-  auto usbSupplyRedirectRuleObj = usbSupplyRedirectRule.at(dep1);
-  std::string usbSupplyRedirectRuleObjStr = std::string("UsbSupplyRedirectRule") + "." + std::to_string(dep1 + 1);
-    setParameter(usbSupplyRedirectRuleObjStr + ".ProductId", usbSupplyRedirectRuleObj.productId);
-    setParameter(usbSupplyRedirectRuleObjStr + ".DeviceSubclass", usbSupplyRedirectRuleObj.deviceSubclass);
-    setParameter(usbSupplyRedirectRuleObjStr + ".UsbRedirectType", std::to_string(usbSupplyRedirectRuleObj.usbRedirectType));
-    setParameter(usbSupplyRedirectRuleObjStr + ".VendorId", usbSupplyRedirectRuleObj.vendorId);
-    setParameter(usbSupplyRedirectRuleObjStr + ".Description", usbSupplyRedirectRuleObj.description);
-    setParameter(usbSupplyRedirectRuleObjStr + ".DeviceClass", usbSupplyRedirectRuleObj.deviceClass);
-    setParameter(usbSupplyRedirectRuleObjStr + ".UsbRuleType", std::to_string(usbSupplyRedirectRuleObj.usbRuleType));
-  }
-}
-
 std::string CreatePolicyGroupRequest::getPrinterRedirection() const {
   return printerRedirection_;
 }
@@ -129,6 +78,15 @@ void CreatePolicyGroupRequest::setLocalDrive(const std::string &localDrive) {
   setParameter(std::string("LocalDrive"), localDrive);
 }
 
+int CreatePolicyGroupRequest::getWatermarkTransparencyValue() const {
+  return watermarkTransparencyValue_;
+}
+
+void CreatePolicyGroupRequest::setWatermarkTransparencyValue(int watermarkTransparencyValue) {
+  watermarkTransparencyValue_ = watermarkTransparencyValue;
+  setParameter(std::string("WatermarkTransparencyValue"), std::to_string(watermarkTransparencyValue));
+}
+
 std::vector<CreatePolicyGroupRequest::AuthorizeSecurityPolicyRule> CreatePolicyGroupRequest::getAuthorizeSecurityPolicyRule() const {
   return authorizeSecurityPolicyRule_;
 }
@@ -148,15 +106,6 @@ void CreatePolicyGroupRequest::setAuthorizeSecurityPolicyRule(const std::vector<
   }
 }
 
-std::string CreatePolicyGroupRequest::getRecording() const {
-  return recording_;
-}
-
-void CreatePolicyGroupRequest::setRecording(const std::string &recording) {
-  recording_ = recording;
-  setParameter(std::string("Recording"), recording);
-}
-
 std::string CreatePolicyGroupRequest::getClipboard() const {
   return clipboard_;
 }
@@ -166,13 +115,13 @@ void CreatePolicyGroupRequest::setClipboard(const std::string &clipboard) {
   setParameter(std::string("Clipboard"), clipboard);
 }
 
-long CreatePolicyGroupRequest::getRecordingFps() const {
-  return recordingFps_;
+std::string CreatePolicyGroupRequest::getEndUserApplyAdminCoordinate() const {
+  return endUserApplyAdminCoordinate_;
 }
 
-void CreatePolicyGroupRequest::setRecordingFps(long recordingFps) {
-  recordingFps_ = recordingFps;
-  setParameter(std::string("RecordingFps"), std::to_string(recordingFps));
+void CreatePolicyGroupRequest::setEndUserApplyAdminCoordinate(const std::string &endUserApplyAdminCoordinate) {
+  endUserApplyAdminCoordinate_ = endUserApplyAdminCoordinate;
+  setParameter(std::string("EndUserApplyAdminCoordinate"), endUserApplyAdminCoordinate);
 }
 
 std::string CreatePolicyGroupRequest::getUsbRedirect() const {
@@ -184,15 +133,6 @@ void CreatePolicyGroupRequest::setUsbRedirect(const std::string &usbRedirect) {
   setParameter(std::string("UsbRedirect"), usbRedirect);
 }
 
-std::string CreatePolicyGroupRequest::getRegionId() const {
-  return regionId_;
-}
-
-void CreatePolicyGroupRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
 std::string CreatePolicyGroupRequest::getWatermarkType() const {
   return watermarkType_;
 }
@@ -211,22 +151,46 @@ void CreatePolicyGroupRequest::setRecordingStartTime(const std::string &recordin
   setParameter(std::string("RecordingStartTime"), recordingStartTime);
 }
 
-std::string CreatePolicyGroupRequest::getRecordContent() const {
-  return recordContent_;
+std::vector<CreatePolicyGroupRequest::NetRedirectRule> CreatePolicyGroupRequest::getNetRedirectRule() const {
+  return netRedirectRule_;
 }
 
-void CreatePolicyGroupRequest::setRecordContent(const std::string &recordContent) {
-  recordContent_ = recordContent;
-  setParameter(std::string("RecordContent"), recordContent);
+void CreatePolicyGroupRequest::setNetRedirectRule(const std::vector<CreatePolicyGroupRequest::NetRedirectRule> &netRedirectRule) {
+  netRedirectRule_ = netRedirectRule;
+  for(int dep1 = 0; dep1 != netRedirectRule.size(); dep1++) {
+  auto netRedirectRuleObj = netRedirectRule.at(dep1);
+  std::string netRedirectRuleObjStr = std::string("NetRedirectRule") + "." + std::to_string(dep1 + 1);
+    setParameter(netRedirectRuleObjStr + ".RuleType", netRedirectRuleObj.ruleType);
+    setParameter(netRedirectRuleObjStr + ".Domain", netRedirectRuleObj.domain);
+    setParameter(netRedirectRuleObjStr + ".Policy", netRedirectRuleObj.policy);
+  }
 }
 
-long CreatePolicyGroupRequest::getRecordContentExpires() const {
-  return recordContentExpires_;
+int CreatePolicyGroupRequest::getRecordingDuration() const {
+  return recordingDuration_;
 }
 
-void CreatePolicyGroupRequest::setRecordContentExpires(long recordContentExpires) {
-  recordContentExpires_ = recordContentExpires;
-  setParameter(std::string("RecordContentExpires"), std::to_string(recordContentExpires));
+void CreatePolicyGroupRequest::setRecordingDuration(int recordingDuration) {
+  recordingDuration_ = recordingDuration;
+  setParameter(std::string("RecordingDuration"), std::to_string(recordingDuration));
+}
+
+int CreatePolicyGroupRequest::getWatermarkColor() const {
+  return watermarkColor_;
+}
+
+void CreatePolicyGroupRequest::setWatermarkColor(int watermarkColor) {
+  watermarkColor_ = watermarkColor;
+  setParameter(std::string("WatermarkColor"), std::to_string(watermarkColor));
+}
+
+int CreatePolicyGroupRequest::getMemoryRateLimit() const {
+  return memoryRateLimit_;
+}
+
+void CreatePolicyGroupRequest::setMemoryRateLimit(int memoryRateLimit) {
+  memoryRateLimit_ = memoryRateLimit;
+  setParameter(std::string("MemoryRateLimit"), std::to_string(memoryRateLimit));
 }
 
 std::string CreatePolicyGroupRequest::getWatermark() const {
@@ -247,6 +211,317 @@ void CreatePolicyGroupRequest::setCameraRedirect(const std::string &cameraRedire
   setParameter(std::string("CameraRedirect"), cameraRedirect);
 }
 
+std::vector<std::string> CreatePolicyGroupRequest::getMemoryProcessors() const {
+  return memoryProcessors_;
+}
+
+void CreatePolicyGroupRequest::setMemoryProcessors(const std::vector<std::string> &memoryProcessors) {
+  memoryProcessors_ = memoryProcessors;
+}
+
+std::string CreatePolicyGroupRequest::getVideoRedirect() const {
+  return videoRedirect_;
+}
+
+void CreatePolicyGroupRequest::setVideoRedirect(const std::string &videoRedirect) {
+  videoRedirect_ = videoRedirect;
+  setParameter(std::string("VideoRedirect"), videoRedirect);
+}
+
+int CreatePolicyGroupRequest::getCpuSingleRateLimit() const {
+  return cpuSingleRateLimit_;
+}
+
+void CreatePolicyGroupRequest::setCpuSingleRateLimit(int cpuSingleRateLimit) {
+  cpuSingleRateLimit_ = cpuSingleRateLimit;
+  setParameter(std::string("CpuSingleRateLimit"), std::to_string(cpuSingleRateLimit));
+}
+
+std::string CreatePolicyGroupRequest::getAppContentProtection() const {
+  return appContentProtection_;
+}
+
+void CreatePolicyGroupRequest::setAppContentProtection(const std::string &appContentProtection) {
+  appContentProtection_ = appContentProtection;
+  setParameter(std::string("AppContentProtection"), appContentProtection);
+}
+
+std::string CreatePolicyGroupRequest::getCpuProtectedMode() const {
+  return cpuProtectedMode_;
+}
+
+void CreatePolicyGroupRequest::setCpuProtectedMode(const std::string &cpuProtectedMode) {
+  cpuProtectedMode_ = cpuProtectedMode;
+  setParameter(std::string("CpuProtectedMode"), cpuProtectedMode);
+}
+
+std::vector<CreatePolicyGroupRequest::DomainResolveRule> CreatePolicyGroupRequest::getDomainResolveRule() const {
+  return domainResolveRule_;
+}
+
+void CreatePolicyGroupRequest::setDomainResolveRule(const std::vector<CreatePolicyGroupRequest::DomainResolveRule> &domainResolveRule) {
+  domainResolveRule_ = domainResolveRule;
+  for(int dep1 = 0; dep1 != domainResolveRule.size(); dep1++) {
+  auto domainResolveRuleObj = domainResolveRule.at(dep1);
+  std::string domainResolveRuleObjStr = std::string("DomainResolveRule") + "." + std::to_string(dep1 + 1);
+    setParameter(domainResolveRuleObjStr + ".Domain", domainResolveRuleObj.domain);
+    setParameter(domainResolveRuleObjStr + ".Description", domainResolveRuleObj.description);
+    setParameter(domainResolveRuleObjStr + ".Policy", domainResolveRuleObj.policy);
+  }
+}
+
+std::vector<CreatePolicyGroupRequest::AuthorizeAccessPolicyRule> CreatePolicyGroupRequest::getAuthorizeAccessPolicyRule() const {
+  return authorizeAccessPolicyRule_;
+}
+
+void CreatePolicyGroupRequest::setAuthorizeAccessPolicyRule(const std::vector<CreatePolicyGroupRequest::AuthorizeAccessPolicyRule> &authorizeAccessPolicyRule) {
+  authorizeAccessPolicyRule_ = authorizeAccessPolicyRule;
+  for(int dep1 = 0; dep1 != authorizeAccessPolicyRule.size(); dep1++) {
+  auto authorizeAccessPolicyRuleObj = authorizeAccessPolicyRule.at(dep1);
+  std::string authorizeAccessPolicyRuleObjStr = std::string("AuthorizeAccessPolicyRule") + "." + std::to_string(dep1 + 1);
+    setParameter(authorizeAccessPolicyRuleObjStr + ".Description", authorizeAccessPolicyRuleObj.description);
+    setParameter(authorizeAccessPolicyRuleObjStr + ".CidrIp", authorizeAccessPolicyRuleObj.cidrIp);
+  }
+}
+
+std::string CreatePolicyGroupRequest::getWatermarkTransparency() const {
+  return watermarkTransparency_;
+}
+
+void CreatePolicyGroupRequest::setWatermarkTransparency(const std::string &watermarkTransparency) {
+  watermarkTransparency_ = watermarkTransparency;
+  setParameter(std::string("WatermarkTransparency"), watermarkTransparency);
+}
+
+std::string CreatePolicyGroupRequest::getName() const {
+  return name_;
+}
+
+void CreatePolicyGroupRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+int CreatePolicyGroupRequest::getMemorySampleDuration() const {
+  return memorySampleDuration_;
+}
+
+void CreatePolicyGroupRequest::setMemorySampleDuration(int memorySampleDuration) {
+  memorySampleDuration_ = memorySampleDuration;
+  setParameter(std::string("MemorySampleDuration"), std::to_string(memorySampleDuration));
+}
+
+std::string CreatePolicyGroupRequest::getWatermarkCustomText() const {
+  return watermarkCustomText_;
+}
+
+void CreatePolicyGroupRequest::setWatermarkCustomText(const std::string &watermarkCustomText) {
+  watermarkCustomText_ = watermarkCustomText;
+  setParameter(std::string("WatermarkCustomText"), watermarkCustomText);
+}
+
+int CreatePolicyGroupRequest::getCpuDownGradeDuration() const {
+  return cpuDownGradeDuration_;
+}
+
+void CreatePolicyGroupRequest::setCpuDownGradeDuration(int cpuDownGradeDuration) {
+  cpuDownGradeDuration_ = cpuDownGradeDuration;
+  setParameter(std::string("CpuDownGradeDuration"), std::to_string(cpuDownGradeDuration));
+}
+
+std::string CreatePolicyGroupRequest::getPreemptLogin() const {
+  return preemptLogin_;
+}
+
+void CreatePolicyGroupRequest::setPreemptLogin(const std::string &preemptLogin) {
+  preemptLogin_ = preemptLogin;
+  setParameter(std::string("PreemptLogin"), preemptLogin);
+}
+
+std::vector<CreatePolicyGroupRequest::ClientType> CreatePolicyGroupRequest::getClientType() const {
+  return clientType_;
+}
+
+void CreatePolicyGroupRequest::setClientType(const std::vector<CreatePolicyGroupRequest::ClientType> &clientType) {
+  clientType_ = clientType;
+  for(int dep1 = 0; dep1 != clientType.size(); dep1++) {
+  auto clientTypeObj = clientType.at(dep1);
+  std::string clientTypeObjStr = std::string("ClientType") + "." + std::to_string(dep1 + 1);
+    setParameter(clientTypeObjStr + ".ClientType", clientTypeObj.clientType);
+    setParameter(clientTypeObjStr + ".Status", clientTypeObj.status);
+  }
+}
+
+std::vector<CreatePolicyGroupRequest::UsbSupplyRedirectRule> CreatePolicyGroupRequest::getUsbSupplyRedirectRule() const {
+  return usbSupplyRedirectRule_;
+}
+
+void CreatePolicyGroupRequest::setUsbSupplyRedirectRule(const std::vector<CreatePolicyGroupRequest::UsbSupplyRedirectRule> &usbSupplyRedirectRule) {
+  usbSupplyRedirectRule_ = usbSupplyRedirectRule;
+  for(int dep1 = 0; dep1 != usbSupplyRedirectRule.size(); dep1++) {
+  auto usbSupplyRedirectRuleObj = usbSupplyRedirectRule.at(dep1);
+  std::string usbSupplyRedirectRuleObjStr = std::string("UsbSupplyRedirectRule") + "." + std::to_string(dep1 + 1);
+    setParameter(usbSupplyRedirectRuleObjStr + ".ProductId", usbSupplyRedirectRuleObj.productId);
+    setParameter(usbSupplyRedirectRuleObjStr + ".DeviceSubclass", usbSupplyRedirectRuleObj.deviceSubclass);
+    setParameter(usbSupplyRedirectRuleObjStr + ".UsbRedirectType", std::to_string(usbSupplyRedirectRuleObj.usbRedirectType));
+    setParameter(usbSupplyRedirectRuleObjStr + ".VendorId", usbSupplyRedirectRuleObj.vendorId);
+    setParameter(usbSupplyRedirectRuleObjStr + ".Description", usbSupplyRedirectRuleObj.description);
+    setParameter(usbSupplyRedirectRuleObjStr + ".DeviceClass", usbSupplyRedirectRuleObj.deviceClass);
+    setParameter(usbSupplyRedirectRuleObjStr + ".UsbRuleType", std::to_string(usbSupplyRedirectRuleObj.usbRuleType));
+  }
+}
+
+int CreatePolicyGroupRequest::getWatermarkFontSize() const {
+  return watermarkFontSize_;
+}
+
+void CreatePolicyGroupRequest::setWatermarkFontSize(int watermarkFontSize) {
+  watermarkFontSize_ = watermarkFontSize;
+  setParameter(std::string("WatermarkFontSize"), std::to_string(watermarkFontSize));
+}
+
+std::string CreatePolicyGroupRequest::getRecording() const {
+  return recording_;
+}
+
+void CreatePolicyGroupRequest::setRecording(const std::string &recording) {
+  recording_ = recording;
+  setParameter(std::string("Recording"), recording);
+}
+
+std::vector<std::string> CreatePolicyGroupRequest::getScopeValue() const {
+  return scopeValue_;
+}
+
+void CreatePolicyGroupRequest::setScopeValue(const std::vector<std::string> &scopeValue) {
+  scopeValue_ = scopeValue;
+}
+
+std::string CreatePolicyGroupRequest::getDomainResolveRuleType() const {
+  return domainResolveRuleType_;
+}
+
+void CreatePolicyGroupRequest::setDomainResolveRuleType(const std::string &domainResolveRuleType) {
+  domainResolveRuleType_ = domainResolveRuleType;
+  setParameter(std::string("DomainResolveRuleType"), domainResolveRuleType);
+}
+
+int CreatePolicyGroupRequest::getMemorySingleRateLimit() const {
+  return memorySingleRateLimit_;
+}
+
+void CreatePolicyGroupRequest::setMemorySingleRateLimit(int memorySingleRateLimit) {
+  memorySingleRateLimit_ = memorySingleRateLimit;
+  setParameter(std::string("MemorySingleRateLimit"), std::to_string(memorySingleRateLimit));
+}
+
+long CreatePolicyGroupRequest::getRecordingFps() const {
+  return recordingFps_;
+}
+
+void CreatePolicyGroupRequest::setRecordingFps(long recordingFps) {
+  recordingFps_ = recordingFps;
+  setParameter(std::string("RecordingFps"), std::to_string(recordingFps));
+}
+
+std::string CreatePolicyGroupRequest::getWatermarkFontStyle() const {
+  return watermarkFontStyle_;
+}
+
+void CreatePolicyGroupRequest::setWatermarkFontStyle(const std::string &watermarkFontStyle) {
+  watermarkFontStyle_ = watermarkFontStyle;
+  setParameter(std::string("WatermarkFontStyle"), watermarkFontStyle);
+}
+
+std::string CreatePolicyGroupRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreatePolicyGroupRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreatePolicyGroupRequest::getRecordContent() const {
+  return recordContent_;
+}
+
+void CreatePolicyGroupRequest::setRecordContent(const std::string &recordContent) {
+  recordContent_ = recordContent;
+  setParameter(std::string("RecordContent"), recordContent);
+}
+
+std::string CreatePolicyGroupRequest::getScope() const {
+  return scope_;
+}
+
+void CreatePolicyGroupRequest::setScope(const std::string &scope) {
+  scope_ = scope;
+  setParameter(std::string("Scope"), scope);
+}
+
+int CreatePolicyGroupRequest::getWatermarkRowAmount() const {
+  return watermarkRowAmount_;
+}
+
+void CreatePolicyGroupRequest::setWatermarkRowAmount(int watermarkRowAmount) {
+  watermarkRowAmount_ = watermarkRowAmount;
+  setParameter(std::string("WatermarkRowAmount"), std::to_string(watermarkRowAmount));
+}
+
+std::vector<std::string> CreatePolicyGroupRequest::getCpuProcessors() const {
+  return cpuProcessors_;
+}
+
+void CreatePolicyGroupRequest::setCpuProcessors(const std::vector<std::string> &cpuProcessors) {
+  cpuProcessors_ = cpuProcessors;
+}
+
+std::string CreatePolicyGroupRequest::getEndUserGroupCoordinate() const {
+  return endUserGroupCoordinate_;
+}
+
+void CreatePolicyGroupRequest::setEndUserGroupCoordinate(const std::string &endUserGroupCoordinate) {
+  endUserGroupCoordinate_ = endUserGroupCoordinate;
+  setParameter(std::string("EndUserGroupCoordinate"), endUserGroupCoordinate);
+}
+
+double CreatePolicyGroupRequest::getWatermarkDegree() const {
+  return watermarkDegree_;
+}
+
+void CreatePolicyGroupRequest::setWatermarkDegree(double watermarkDegree) {
+  watermarkDegree_ = watermarkDegree;
+  setParameter(std::string("WatermarkDegree"), std::to_string(watermarkDegree));
+}
+
+long CreatePolicyGroupRequest::getRecordContentExpires() const {
+  return recordContentExpires_;
+}
+
+void CreatePolicyGroupRequest::setRecordContentExpires(long recordContentExpires) {
+  recordContentExpires_ = recordContentExpires;
+  setParameter(std::string("RecordContentExpires"), std::to_string(recordContentExpires));
+}
+
+std::string CreatePolicyGroupRequest::getRecordingAudio() const {
+  return recordingAudio_;
+}
+
+void CreatePolicyGroupRequest::setRecordingAudio(const std::string &recordingAudio) {
+  recordingAudio_ = recordingAudio;
+  setParameter(std::string("RecordingAudio"), recordingAudio);
+}
+
+int CreatePolicyGroupRequest::getCpuRateLimit() const {
+  return cpuRateLimit_;
+}
+
+void CreatePolicyGroupRequest::setCpuRateLimit(int cpuRateLimit) {
+  cpuRateLimit_ = cpuRateLimit;
+  setParameter(std::string("CpuRateLimit"), std::to_string(cpuRateLimit));
+}
+
 std::string CreatePolicyGroupRequest::getRemoteCoordinate() const {
   return remoteCoordinate_;
 }
@@ -256,6 +531,15 @@ void CreatePolicyGroupRequest::setRemoteCoordinate(const std::string &remoteCoor
   setParameter(std::string("RemoteCoordinate"), remoteCoordinate);
 }
 
+int CreatePolicyGroupRequest::getCpuSampleDuration() const {
+  return cpuSampleDuration_;
+}
+
+void CreatePolicyGroupRequest::setCpuSampleDuration(int cpuSampleDuration) {
+  cpuSampleDuration_ = cpuSampleDuration;
+  setParameter(std::string("CpuSampleDuration"), std::to_string(cpuSampleDuration));
+}
+
 std::string CreatePolicyGroupRequest::getHtml5Access() const {
   return html5Access_;
 }
@@ -283,29 +567,6 @@ void CreatePolicyGroupRequest::setHtml5FileTransfer(const std::string &html5File
   setParameter(std::string("Html5FileTransfer"), html5FileTransfer);
 }
 
-std::string CreatePolicyGroupRequest::getAppContentProtection() const {
-  return appContentProtection_;
-}
-
-void CreatePolicyGroupRequest::setAppContentProtection(const std::string &appContentProtection) {
-  appContentProtection_ = appContentProtection;
-  setParameter(std::string("AppContentProtection"), appContentProtection);
-}
-
-std::vector<CreatePolicyGroupRequest::AuthorizeAccessPolicyRule> CreatePolicyGroupRequest::getAuthorizeAccessPolicyRule() const {
-  return authorizeAccessPolicyRule_;
-}
-
-void CreatePolicyGroupRequest::setAuthorizeAccessPolicyRule(const std::vector<CreatePolicyGroupRequest::AuthorizeAccessPolicyRule> &authorizeAccessPolicyRule) {
-  authorizeAccessPolicyRule_ = authorizeAccessPolicyRule;
-  for(int dep1 = 0; dep1 != authorizeAccessPolicyRule.size(); dep1++) {
-  auto authorizeAccessPolicyRuleObj = authorizeAccessPolicyRule.at(dep1);
-  std::string authorizeAccessPolicyRuleObjStr = std::string("AuthorizeAccessPolicyRule") + "." + std::to_string(dep1 + 1);
-    setParameter(authorizeAccessPolicyRuleObjStr + ".Description", authorizeAccessPolicyRuleObj.description);
-    setParameter(authorizeAccessPolicyRuleObjStr + ".CidrIp", authorizeAccessPolicyRuleObj.cidrIp);
-  }
-}
-
 std::string CreatePolicyGroupRequest::getVisualQuality() const {
   return visualQuality_;
 }
@@ -315,24 +576,6 @@ void CreatePolicyGroupRequest::setVisualQuality(const std::string &visualQuality
   setParameter(std::string("VisualQuality"), visualQuality);
 }
 
-std::string CreatePolicyGroupRequest::getWatermarkTransparency() const {
-  return watermarkTransparency_;
-}
-
-void CreatePolicyGroupRequest::setWatermarkTransparency(const std::string &watermarkTransparency) {
-  watermarkTransparency_ = watermarkTransparency;
-  setParameter(std::string("WatermarkTransparency"), watermarkTransparency);
-}
-
-std::string CreatePolicyGroupRequest::getName() const {
-  return name_;
-}
-
-void CreatePolicyGroupRequest::setName(const std::string &name) {
-  name_ = name;
-  setParameter(std::string("Name"), name);
-}
-
 std::string CreatePolicyGroupRequest::getRecordingEndTime() const {
   return recordingEndTime_;
 }
@@ -342,3 +585,30 @@ void CreatePolicyGroupRequest::setRecordingEndTime(const std::string &recordingE
   setParameter(std::string("RecordingEndTime"), recordingEndTime);
 }
 
+std::string CreatePolicyGroupRequest::getMemoryProtectedMode() const {
+  return memoryProtectedMode_;
+}
+
+void CreatePolicyGroupRequest::setMemoryProtectedMode(const std::string &memoryProtectedMode) {
+  memoryProtectedMode_ = memoryProtectedMode;
+  setParameter(std::string("MemoryProtectedMode"), memoryProtectedMode);
+}
+
+int CreatePolicyGroupRequest::getMemoryDownGradeDuration() const {
+  return memoryDownGradeDuration_;
+}
+
+void CreatePolicyGroupRequest::setMemoryDownGradeDuration(int memoryDownGradeDuration) {
+  memoryDownGradeDuration_ = memoryDownGradeDuration;
+  setParameter(std::string("MemoryDownGradeDuration"), std::to_string(memoryDownGradeDuration));
+}
+
+std::string CreatePolicyGroupRequest::getInternetCommunicationProtocol() const {
+  return internetCommunicationProtocol_;
+}
+
+void CreatePolicyGroupRequest::setInternetCommunicationProtocol(const std::string &internetCommunicationProtocol) {
+  internetCommunicationProtocol_ = internetCommunicationProtocol;
+  setParameter(std::string("InternetCommunicationProtocol"), internetCommunicationProtocol);
+}
+

ecd/src/model/CreateSimpleOfficeSiteRequest.cc

@@ -25,6 +25,15 @@ CreateSimpleOfficeSiteRequest::CreateSimpleOfficeSiteRequest()
 
 CreateSimpleOfficeSiteRequest::~CreateSimpleOfficeSiteRequest() {}
 
+std::string CreateSimpleOfficeSiteRequest::getVpcType() const {
+  return vpcType_;
+}
+
+void CreateSimpleOfficeSiteRequest::setVpcType(const std::string &vpcType) {
+  vpcType_ = vpcType;
+  setParameter(std::string("VpcType"), vpcType);
+}
+
 std::string CreateSimpleOfficeSiteRequest::getCenId() const {
   return cenId_;
 }

ecd/src/model/DeleteAutoSnapshotPolicyRequest.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/ecd/model/DeleteAutoSnapshotPolicyRequest.h>
+
+using AlibabaCloud::Ecd::Model::DeleteAutoSnapshotPolicyRequest;
+
+DeleteAutoSnapshotPolicyRequest::DeleteAutoSnapshotPolicyRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DeleteAutoSnapshotPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteAutoSnapshotPolicyRequest::~DeleteAutoSnapshotPolicyRequest() {}
+
+std::vector<std::string> DeleteAutoSnapshotPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void DeleteAutoSnapshotPolicyRequest::setPolicyId(const std::vector<std::string> &policyId) {
+  policyId_ = policyId;
+}
+
+std::string DeleteAutoSnapshotPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteAutoSnapshotPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ecd/src/model/DeleteCdsFileRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/DeleteCdsFileRequest.h>
+
+using AlibabaCloud::Ecd::Model::DeleteCdsFileRequest;
+
+DeleteCdsFileRequest::DeleteCdsFileRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DeleteCdsFile") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteCdsFileRequest::~DeleteCdsFileRequest() {}
+
+std::string DeleteCdsFileRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void DeleteCdsFileRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string DeleteCdsFileRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteCdsFileRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteCdsFileRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void DeleteCdsFileRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string DeleteCdsFileRequest::getFileId() const {
+  return fileId_;
+}
+
+void DeleteCdsFileRequest::setFileId(const std::string &fileId) {
+  fileId_ = fileId;
+  setParameter(std::string("FileId"), fileId);
+}
+

ecd/src/model/DeleteCdsFileResult.cc

@@ -14,58 +14,58 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ecd/model/DeleteDriveResult.h>
+#include <alibabacloud/ecd/model/DeleteCdsFileResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Ecd;
 using namespace AlibabaCloud::Ecd::Model;
 
-DeleteDriveResult::DeleteDriveResult() :
+DeleteCdsFileResult::DeleteCdsFileResult() :
 	ServiceResult()
 {}
 
-DeleteDriveResult::DeleteDriveResult(const std::string &payload) :
+DeleteCdsFileResult::DeleteCdsFileResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteDriveResult::~DeleteDriveResult()
+DeleteCdsFileResult::~DeleteCdsFileResult()
 {}
 
-void DeleteDriveResult::parse(const std::string &payload)
+void DeleteCdsFileResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
-	if(!value["Data"].isNull())
-		data_ = value["Data"].asString() == "true";
 
 }
 
-std::string DeleteDriveResult::getMessage()const
+std::string DeleteCdsFileResult::getMessage()const
 {
 	return message_;
 }
 
-bool DeleteDriveResult::getData()const
+std::string DeleteCdsFileResult::getData()const
 {
 	return data_;
 }
 
-std::string DeleteDriveResult::getCode()const
+std::string DeleteCdsFileResult::getCode()const
 {
 	return code_;
 }
 
-bool DeleteDriveResult::getSuccess()const
+bool DeleteCdsFileResult::getSuccess()const
 {
 	return success_;
 }

ecd/src/model/DeleteCloudDriveGroupsRequest.cc

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/DeleteCloudDriveGroupsRequest.h>
+
+using AlibabaCloud::Ecd::Model::DeleteCloudDriveGroupsRequest;
+
+DeleteCloudDriveGroupsRequest::DeleteCloudDriveGroupsRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DeleteCloudDriveGroups") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteCloudDriveGroupsRequest::~DeleteCloudDriveGroupsRequest() {}
+
+std::vector<std::string> DeleteCloudDriveGroupsRequest::getGroupId() const {
+  return groupId_;
+}
+
+void DeleteCloudDriveGroupsRequest::setGroupId(const std::vector<std::string> &groupId) {
+  groupId_ = groupId;
+}
+
+std::string DeleteCloudDriveGroupsRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void DeleteCloudDriveGroupsRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string DeleteCloudDriveGroupsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteCloudDriveGroupsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

ecd/src/model/DeleteCloudDriveGroupsResult.cc

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

ecd/src/model/DeleteDevicesRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/DeleteDevicesRequest.h>
+
+using AlibabaCloud::Ecd::Model::DeleteDevicesRequest;
+
+DeleteDevicesRequest::DeleteDevicesRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DeleteDevices") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDevicesRequest::~DeleteDevicesRequest() {}
+
+int DeleteDevicesRequest::getClientType() const {
+  return clientType_;
+}
+
+void DeleteDevicesRequest::setClientType(int clientType) {
+  clientType_ = clientType;
+  setParameter(std::string("ClientType"), std::to_string(clientType));
+}
+
+std::vector<std::string> DeleteDevicesRequest::getDeviceIds() const {
+  return deviceIds_;
+}
+
+void DeleteDevicesRequest::setDeviceIds(const std::vector<std::string> &deviceIds) {
+  deviceIds_ = deviceIds;
+}
+
+std::string DeleteDevicesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteDevicesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DeleteDevicesRequest::getForce() const {
+  return force_;
+}
+
+void DeleteDevicesRequest::setForce(int force) {
+  force_ = force;
+  setParameter(std::string("Force"), std::to_string(force));
+}
+

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

ecd/src/model/DeleteImagesRequest.cc

@@ -42,3 +42,12 @@ void DeleteImagesRequest::setRegionId(const std::string &regionId) {
   setParameter(std::string("RegionId"), regionId);
 }
 
+bool DeleteImagesRequest::getDeleteCascadedBundle() const {
+  return deleteCascadedBundle_;
+}
+
+void DeleteImagesRequest::setDeleteCascadedBundle(bool deleteCascadedBundle) {
+  deleteCascadedBundle_ = deleteCascadedBundle;
+  setParameter(std::string("DeleteCascadedBundle"), deleteCascadedBundle ? "true" : "false");
+}
+

ecd/src/model/DescribeAutoSnapshotPolicyRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/DescribeAutoSnapshotPolicyRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeAutoSnapshotPolicyRequest;
+
+DescribeAutoSnapshotPolicyRequest::DescribeAutoSnapshotPolicyRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeAutoSnapshotPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeAutoSnapshotPolicyRequest::~DescribeAutoSnapshotPolicyRequest() {}
+
+std::string DescribeAutoSnapshotPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void DescribeAutoSnapshotPolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string DescribeAutoSnapshotPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeAutoSnapshotPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeAutoSnapshotPolicyRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeAutoSnapshotPolicyRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+int DescribeAutoSnapshotPolicyRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeAutoSnapshotPolicyRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string DescribeAutoSnapshotPolicyRequest::getPolicyName() const {
+  return policyName_;
+}
+
+void DescribeAutoSnapshotPolicyRequest::setPolicyName(const std::string &policyName) {
+  policyName_ = policyName;
+  setParameter(std::string("PolicyName"), policyName);
+}
+

ecd/src/model/DescribeAutoSnapshotPolicyResult.cc

@@ -0,0 +1,80 @@
+/*
+ * 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/ecd/model/DescribeAutoSnapshotPolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeAutoSnapshotPolicyResult::DescribeAutoSnapshotPolicyResult() :
+	ServiceResult()
+{}
+
+DescribeAutoSnapshotPolicyResult::DescribeAutoSnapshotPolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAutoSnapshotPolicyResult::~DescribeAutoSnapshotPolicyResult()
+{}
+
+void DescribeAutoSnapshotPolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAutoSnapshotPoliciesNode = value["AutoSnapshotPolicies"]["AutoSnapshotPolicy"];
+	for (auto valueAutoSnapshotPoliciesAutoSnapshotPolicy : allAutoSnapshotPoliciesNode)
+	{
+		AutoSnapshotPolicy autoSnapshotPoliciesObject;
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["TimePoints"].isNull())
+			autoSnapshotPoliciesObject.timePoints = valueAutoSnapshotPoliciesAutoSnapshotPolicy["TimePoints"].asString();
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["CreationTime"].isNull())
+			autoSnapshotPoliciesObject.creationTime = valueAutoSnapshotPoliciesAutoSnapshotPolicy["CreationTime"].asString();
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["Status"].isNull())
+			autoSnapshotPoliciesObject.status = valueAutoSnapshotPoliciesAutoSnapshotPolicy["Status"].asString();
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["DesktopNum"].isNull())
+			autoSnapshotPoliciesObject.desktopNum = std::stoi(valueAutoSnapshotPoliciesAutoSnapshotPolicy["DesktopNum"].asString());
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["CronExpression"].isNull())
+			autoSnapshotPoliciesObject.cronExpression = valueAutoSnapshotPoliciesAutoSnapshotPolicy["CronExpression"].asString();
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["RetentionDays"].isNull())
+			autoSnapshotPoliciesObject.retentionDays = valueAutoSnapshotPoliciesAutoSnapshotPolicy["RetentionDays"].asString();
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["PolicyName"].isNull())
+			autoSnapshotPoliciesObject.policyName = valueAutoSnapshotPoliciesAutoSnapshotPolicy["PolicyName"].asString();
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["PolicyId"].isNull())
+			autoSnapshotPoliciesObject.policyId = valueAutoSnapshotPoliciesAutoSnapshotPolicy["PolicyId"].asString();
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["RegionId"].isNull())
+			autoSnapshotPoliciesObject.regionId = valueAutoSnapshotPoliciesAutoSnapshotPolicy["RegionId"].asString();
+		autoSnapshotPolicies_.push_back(autoSnapshotPoliciesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::string DescribeAutoSnapshotPolicyResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<DescribeAutoSnapshotPolicyResult::AutoSnapshotPolicy> DescribeAutoSnapshotPolicyResult::getAutoSnapshotPolicies()const
+{
+	return autoSnapshotPolicies_;
+}
+

ecd/src/model/DescribeBundlesRequest.cc

@@ -34,6 +34,14 @@ void DescribeBundlesRequest::setGpuCount(float gpuCount) {
   setParameter(std::string("GpuCount"), std::to_string(gpuCount));
 }
 
+std::vector<std::string> DescribeBundlesRequest::getImageId() const {
+  return imageId_;
+}
+
+void DescribeBundlesRequest::setImageId(const std::vector<std::string> &imageId) {
+  imageId_ = imageId;
+}
+
 std::vector<std::string> DescribeBundlesRequest::getBundleId() const {
   return bundleId_;
 }
@@ -51,6 +59,15 @@ void DescribeBundlesRequest::setDesktopTypeFamily(const std::string &desktopType
   setParameter(std::string("DesktopTypeFamily"), desktopTypeFamily);
 }
 
+bool DescribeBundlesRequest::getSelectedBundle() const {
+  return selectedBundle_;
+}
+
+void DescribeBundlesRequest::setSelectedBundle(bool selectedBundle) {
+  selectedBundle_ = selectedBundle;
+  setParameter(std::string("SelectedBundle"), selectedBundle ? "true" : "false");
+}
+
 std::string DescribeBundlesRequest::getRegionId() const {
   return regionId_;
 }
@@ -114,6 +131,24 @@ void DescribeBundlesRequest::setMemorySize(int memorySize) {
   setParameter(std::string("MemorySize"), std::to_string(memorySize));
 }
 
+std::string DescribeBundlesRequest::getSessionType() const {
+  return sessionType_;
+}
+
+void DescribeBundlesRequest::setSessionType(const std::string &sessionType) {
+  sessionType_ = sessionType;
+  setParameter(std::string("SessionType"), sessionType);
+}
+
+std::string DescribeBundlesRequest::getOsType() const {
+  return osType_;
+}
+
+void DescribeBundlesRequest::setOsType(const std::string &osType) {
+  osType_ = osType;
+  setParameter(std::string("OsType"), osType);
+}
+
 int DescribeBundlesRequest::getMaxResults() const {
   return maxResults_;
 }

ecd/src/model/DescribeBundlesResult.cc

@@ -77,6 +77,8 @@ void DescribeBundlesResult::parse(const std::string &payload)
 			bundlesObject.volumeEncryptionKey = valueBundlesBundle["VolumeEncryptionKey"].asString();
 		if(!valueBundlesBundle["Platform"].isNull())
 			bundlesObject.platform = valueBundlesBundle["Platform"].asString();
+		if(!valueBundlesBundle["ImageStatus"].isNull())
+			bundlesObject.imageStatus = valueBundlesBundle["ImageStatus"].asString();
 		auto allDisksNode = valueBundlesBundle["Disks"]["Disk"];
 		for (auto valueBundlesBundleDisksDisk : allDisksNode)
 		{

ecd/src/model/DescribeCdsFileShareLinksRequest.cc

@@ -0,0 +1,89 @@
+/*
+ * 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/ecd/model/DescribeCdsFileShareLinksRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeCdsFileShareLinksRequest;
+
+DescribeCdsFileShareLinksRequest::DescribeCdsFileShareLinksRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeCdsFileShareLinks") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCdsFileShareLinksRequest::~DescribeCdsFileShareLinksRequest() {}
+
+std::vector<std::string> DescribeCdsFileShareLinksRequest::getCreators() const {
+  return creators_;
+}
+
+void DescribeCdsFileShareLinksRequest::setCreators(const std::vector<std::string> &creators) {
+  creators_ = creators;
+}
+
+std::string DescribeCdsFileShareLinksRequest::getShareId() const {
+  return shareId_;
+}
+
+void DescribeCdsFileShareLinksRequest::setShareId(const std::string &shareId) {
+  shareId_ = shareId;
+  setParameter(std::string("ShareId"), shareId);
+}
+
+std::string DescribeCdsFileShareLinksRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void DescribeCdsFileShareLinksRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string DescribeCdsFileShareLinksRequest::getShareName() const {
+  return shareName_;
+}
+
+void DescribeCdsFileShareLinksRequest::setShareName(const std::string &shareName) {
+  shareName_ = shareName;
+  setParameter(std::string("ShareName"), shareName);
+}
+
+std::string DescribeCdsFileShareLinksRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeCdsFileShareLinksRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+int DescribeCdsFileShareLinksRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeCdsFileShareLinksRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string DescribeCdsFileShareLinksRequest::getStatus() const {
+  return status_;
+}
+
+void DescribeCdsFileShareLinksRequest::setStatus(const std::string &status) {
+  status_ = status;
+  setParameter(std::string("Status"), status);
+}
+

ecd/src/model/DescribeCdsFileShareLinksResult.cc

@@ -0,0 +1,133 @@
+/*
+ * 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/ecd/model/DescribeCdsFileShareLinksResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeCdsFileShareLinksResult::DescribeCdsFileShareLinksResult() :
+	ServiceResult()
+{}
+
+DescribeCdsFileShareLinksResult::DescribeCdsFileShareLinksResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCdsFileShareLinksResult::~DescribeCdsFileShareLinksResult()
+{}
+
+void DescribeCdsFileShareLinksResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["CdsFileShareLinkModel"];
+	for (auto valueDataCdsFileShareLinkModel : allDataNode)
+	{
+		CdsFileShareLinkModel dataObject;
+		if(!valueDataCdsFileShareLinkModel["Description"].isNull())
+			dataObject.description = valueDataCdsFileShareLinkModel["Description"].asString();
+		if(!valueDataCdsFileShareLinkModel["SaveLimit"].isNull())
+			dataObject.saveLimit = std::stol(valueDataCdsFileShareLinkModel["SaveLimit"].asString());
+		if(!valueDataCdsFileShareLinkModel["DownloadCount"].isNull())
+			dataObject.downloadCount = std::stol(valueDataCdsFileShareLinkModel["DownloadCount"].asString());
+		if(!valueDataCdsFileShareLinkModel["Creator"].isNull())
+			dataObject.creator = valueDataCdsFileShareLinkModel["Creator"].asString();
+		if(!valueDataCdsFileShareLinkModel["SaveCount"].isNull())
+			dataObject.saveCount = std::stol(valueDataCdsFileShareLinkModel["SaveCount"].asString());
+		if(!valueDataCdsFileShareLinkModel["DisableSave"].isNull())
+			dataObject.disableSave = valueDataCdsFileShareLinkModel["DisableSave"].asString() == "true";
+		if(!valueDataCdsFileShareLinkModel["SharePwd"].isNull())
+			dataObject.sharePwd = valueDataCdsFileShareLinkModel["SharePwd"].asString();
+		if(!valueDataCdsFileShareLinkModel["DisablePreview"].isNull())
+			dataObject.disablePreview = valueDataCdsFileShareLinkModel["DisablePreview"].asString() == "true";
+		if(!valueDataCdsFileShareLinkModel["AccessCount"].isNull())
+			dataObject.accessCount = std::stol(valueDataCdsFileShareLinkModel["AccessCount"].asString());
+		if(!valueDataCdsFileShareLinkModel["ShareId"].isNull())
+			dataObject.shareId = valueDataCdsFileShareLinkModel["ShareId"].asString();
+		if(!valueDataCdsFileShareLinkModel["DownloadLimit"].isNull())
+			dataObject.downloadLimit = std::stol(valueDataCdsFileShareLinkModel["DownloadLimit"].asString());
+		if(!valueDataCdsFileShareLinkModel["Status"].isNull())
+			dataObject.status = valueDataCdsFileShareLinkModel["Status"].asString();
+		if(!valueDataCdsFileShareLinkModel["DriveId"].isNull())
+			dataObject.driveId = valueDataCdsFileShareLinkModel["DriveId"].asString();
+		if(!valueDataCdsFileShareLinkModel["ModifiyTime"].isNull())
+			dataObject.modifiyTime = valueDataCdsFileShareLinkModel["ModifiyTime"].asString();
+		if(!valueDataCdsFileShareLinkModel["DisableDownload"].isNull())
+			dataObject.disableDownload = valueDataCdsFileShareLinkModel["DisableDownload"].asString() == "true";
+		if(!valueDataCdsFileShareLinkModel["Expiration"].isNull())
+			dataObject.expiration = valueDataCdsFileShareLinkModel["Expiration"].asString();
+		if(!valueDataCdsFileShareLinkModel["Expired"].isNull())
+			dataObject.expired = valueDataCdsFileShareLinkModel["Expired"].asString() == "true";
+		if(!valueDataCdsFileShareLinkModel["PreviewCount"].isNull())
+			dataObject.previewCount = std::stol(valueDataCdsFileShareLinkModel["PreviewCount"].asString());
+		if(!valueDataCdsFileShareLinkModel["PreviewLimit"].isNull())
+			dataObject.previewLimit = std::stol(valueDataCdsFileShareLinkModel["PreviewLimit"].asString());
+		if(!valueDataCdsFileShareLinkModel["VideoPreviewCount"].isNull())
+			dataObject.videoPreviewCount = std::stol(valueDataCdsFileShareLinkModel["VideoPreviewCount"].asString());
+		if(!valueDataCdsFileShareLinkModel["ReportCount"].isNull())
+			dataObject.reportCount = std::stol(valueDataCdsFileShareLinkModel["ReportCount"].asString());
+		if(!valueDataCdsFileShareLinkModel["FileIds"].isNull())
+			dataObject.fileIds = valueDataCdsFileShareLinkModel["FileIds"].asString();
+		if(!valueDataCdsFileShareLinkModel["ShareName"].isNull())
+			dataObject.shareName = valueDataCdsFileShareLinkModel["ShareName"].asString();
+		if(!valueDataCdsFileShareLinkModel["CreateTime"].isNull())
+			dataObject.createTime = valueDataCdsFileShareLinkModel["CreateTime"].asString();
+		if(!valueDataCdsFileShareLinkModel["ShareLink"].isNull())
+			dataObject.shareLink = valueDataCdsFileShareLinkModel["ShareLink"].asString();
+		data_.push_back(dataObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string DescribeCdsFileShareLinksResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string DescribeCdsFileShareLinksResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<DescribeCdsFileShareLinksResult::CdsFileShareLinkModel> DescribeCdsFileShareLinksResult::getData()const
+{
+	return data_;
+}
+
+std::string DescribeCdsFileShareLinksResult::getCode()const
+{
+	return code_;
+}
+
+bool DescribeCdsFileShareLinksResult::getSuccess()const
+{
+	return success_;
+}
+

ecd/src/model/DescribeCloudDriveGroupsRequest.cc

@@ -0,0 +1,134 @@
+/*
+ * 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/ecd/model/DescribeCloudDriveGroupsRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeCloudDriveGroupsRequest;
+
+DescribeCloudDriveGroupsRequest::DescribeCloudDriveGroupsRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeCloudDriveGroups") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCloudDriveGroupsRequest::~DescribeCloudDriveGroupsRequest() {}
+
+std::string DescribeCloudDriveGroupsRequest::getParentGroupId() const {
+  return parentGroupId_;
+}
+
+void DescribeCloudDriveGroupsRequest::setParentGroupId(const std::string &parentGroupId) {
+  parentGroupId_ = parentGroupId;
+  setParameter(std::string("ParentGroupId"), parentGroupId);
+}
+
+std::string DescribeCloudDriveGroupsRequest::getGroupType() const {
+  return groupType_;
+}
+
+void DescribeCloudDriveGroupsRequest::setGroupType(const std::string &groupType) {
+  groupType_ = groupType;
+  setParameter(std::string("GroupType"), groupType);
+}
+
+std::string DescribeCloudDriveGroupsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeCloudDriveGroupsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeCloudDriveGroupsRequest::getDriveType() const {
+  return driveType_;
+}
+
+void DescribeCloudDriveGroupsRequest::setDriveType(const std::string &driveType) {
+  driveType_ = driveType;
+  setParameter(std::string("DriveType"), driveType);
+}
+
+std::string DescribeCloudDriveGroupsRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeCloudDriveGroupsRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string DescribeCloudDriveGroupsRequest::getDirectoryId() const {
+  return directoryId_;
+}
+
+void DescribeCloudDriveGroupsRequest::setDirectoryId(const std::string &directoryId) {
+  directoryId_ = directoryId;
+  setParameter(std::string("DirectoryId"), directoryId);
+}
+
+std::vector<std::string> DescribeCloudDriveGroupsRequest::getGroupId() const {
+  return groupId_;
+}
+
+void DescribeCloudDriveGroupsRequest::setGroupId(const std::vector<std::string> &groupId) {
+  groupId_ = groupId;
+}
+
+std::string DescribeCloudDriveGroupsRequest::getDirectoryName() const {
+  return directoryName_;
+}
+
+void DescribeCloudDriveGroupsRequest::setDirectoryName(const std::string &directoryName) {
+  directoryName_ = directoryName;
+  setParameter(std::string("DirectoryName"), directoryName);
+}
+
+std::string DescribeCloudDriveGroupsRequest::getGroupName() const {
+  return groupName_;
+}
+
+void DescribeCloudDriveGroupsRequest::setGroupName(const std::string &groupName) {
+  groupName_ = groupName;
+  setParameter(std::string("GroupName"), groupName);
+}
+
+std::string DescribeCloudDriveGroupsRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void DescribeCloudDriveGroupsRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string DescribeCloudDriveGroupsRequest::getDriveStatus() const {
+  return driveStatus_;
+}
+
+void DescribeCloudDriveGroupsRequest::setDriveStatus(const std::string &driveStatus) {
+  driveStatus_ = driveStatus;
+  setParameter(std::string("DriveStatus"), driveStatus);
+}
+
+int DescribeCloudDriveGroupsRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeCloudDriveGroupsRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

ecd/src/model/DescribeCloudDriveGroupsResult.cc

@@ -0,0 +1,92 @@
+/*
+ * 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/ecd/model/DescribeCloudDriveGroupsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeCloudDriveGroupsResult::DescribeCloudDriveGroupsResult() :
+	ServiceResult()
+{}
+
+DescribeCloudDriveGroupsResult::DescribeCloudDriveGroupsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCloudDriveGroupsResult::~DescribeCloudDriveGroupsResult()
+{}
+
+void DescribeCloudDriveGroupsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCloudDriveGroupsNode = value["CloudDriveGroups"]["CloudDriveGroup"];
+	for (auto valueCloudDriveGroupsCloudDriveGroup : allCloudDriveGroupsNode)
+	{
+		CloudDriveGroup cloudDriveGroupsObject;
+		if(!valueCloudDriveGroupsCloudDriveGroup["Status"].isNull())
+			cloudDriveGroupsObject.status = valueCloudDriveGroupsCloudDriveGroup["Status"].asString();
+		if(!valueCloudDriveGroupsCloudDriveGroup["GroupId"].isNull())
+			cloudDriveGroupsObject.groupId = valueCloudDriveGroupsCloudDriveGroup["GroupId"].asString();
+		if(!valueCloudDriveGroupsCloudDriveGroup["GroupName"].isNull())
+			cloudDriveGroupsObject.groupName = valueCloudDriveGroupsCloudDriveGroup["GroupName"].asString();
+		if(!valueCloudDriveGroupsCloudDriveGroup["DirectoryId"].isNull())
+			cloudDriveGroupsObject.directoryId = valueCloudDriveGroupsCloudDriveGroup["DirectoryId"].asString();
+		if(!valueCloudDriveGroupsCloudDriveGroup["DriveId"].isNull())
+			cloudDriveGroupsObject.driveId = valueCloudDriveGroupsCloudDriveGroup["DriveId"].asString();
+		if(!valueCloudDriveGroupsCloudDriveGroup["CreateTime"].isNull())
+			cloudDriveGroupsObject.createTime = valueCloudDriveGroupsCloudDriveGroup["CreateTime"].asString();
+		if(!valueCloudDriveGroupsCloudDriveGroup["TotalSize"].isNull())
+			cloudDriveGroupsObject.totalSize = std::stol(valueCloudDriveGroupsCloudDriveGroup["TotalSize"].asString());
+		if(!valueCloudDriveGroupsCloudDriveGroup["UsedSize"].isNull())
+			cloudDriveGroupsObject.usedSize = valueCloudDriveGroupsCloudDriveGroup["UsedSize"].asString();
+		cloudDriveGroups_.push_back(cloudDriveGroupsObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["Count"].isNull())
+		count_ = std::stol(value["Count"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string DescribeCloudDriveGroupsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+long DescribeCloudDriveGroupsResult::getCount()const
+{
+	return count_;
+}
+
+std::vector<DescribeCloudDriveGroupsResult::CloudDriveGroup> DescribeCloudDriveGroupsResult::getCloudDriveGroups()const
+{
+	return cloudDriveGroups_;
+}
+
+bool DescribeCloudDriveGroupsResult::getSuccess()const
+{
+	return success_;
+}
+

ecd/src/model/DescribeDesktopGroupsRequest.cc

@@ -42,6 +42,22 @@ void DescribeDesktopGroupsRequest::setEndUserIds(const std::vector<std::string>
   endUserIds_ = endUserIds;
 }
 
+std::vector<std::string> DescribeDesktopGroupsRequest::getImageId() const {
+  return imageId_;
+}
+
+void DescribeDesktopGroupsRequest::setImageId(const std::vector<std::string> &imageId) {
+  imageId_ = imageId;
+}
+
+std::vector<std::string> DescribeDesktopGroupsRequest::getBundleId() const {
+  return bundleId_;
+}
+
+void DescribeDesktopGroupsRequest::setBundleId(const std::vector<std::string> &bundleId) {
+  bundleId_ = bundleId;
+}
+
 std::string DescribeDesktopGroupsRequest::getDesktopGroupName() const {
   return desktopGroupName_;
 }
@@ -122,6 +138,15 @@ void DescribeDesktopGroupsRequest::setMaxResults(int maxResults) {
   setParameter(std::string("MaxResults"), std::to_string(maxResults));
 }
 
+std::string DescribeDesktopGroupsRequest::getProtocolType() const {
+  return protocolType_;
+}
+
+void DescribeDesktopGroupsRequest::setProtocolType(const std::string &protocolType) {
+  protocolType_ = protocolType;
+  setParameter(std::string("ProtocolType"), protocolType);
+}
+
 std::string DescribeDesktopGroupsRequest::getPolicyGroupId() const {
   return policyGroupId_;
 }

ecd/src/model/DescribeDesktopGroupsResult.cc

@@ -125,6 +125,12 @@ void DescribeDesktopGroupsResult::parse(const std::string &payload)
 			desktopGroupsObject.version = std::stoi(valueDesktopGroupsDesktopGroup["Version"].asString());
 		if(!valueDesktopGroupsDesktopGroup["StopDuration"].isNull())
 			desktopGroupsObject.stopDuration = std::stol(valueDesktopGroupsDesktopGroup["StopDuration"].asString());
+		if(!valueDesktopGroupsDesktopGroup["ProtocolType"].isNull())
+			desktopGroupsObject.protocolType = valueDesktopGroupsDesktopGroup["ProtocolType"].asString();
+		if(!valueDesktopGroupsDesktopGroup["OsType"].isNull())
+			desktopGroupsObject.osType = valueDesktopGroupsDesktopGroup["OsType"].asString();
+		if(!valueDesktopGroupsDesktopGroup["BuyDesktopsCount"].isNull())
+			desktopGroupsObject.buyDesktopsCount = std::stoi(valueDesktopGroupsDesktopGroup["BuyDesktopsCount"].asString());
 		desktopGroups_.push_back(desktopGroupsObject);
 	}
 	if(!value["NextToken"].isNull())

ecd/src/model/DescribeDesktopsInGroupResult.cc

@@ -75,6 +75,10 @@ void DescribeDesktopsInGroupResult::parse(const std::string &payload)
 			paidDesktopsObject.memberEniIp = valuePaidDesktopsPaidDesktop["MemberEniIp"].asString();
 		if(!valuePaidDesktopsPaidDesktop["PrimaryEniIp"].isNull())
 			paidDesktopsObject.primaryEniIp = valuePaidDesktopsPaidDesktop["PrimaryEniIp"].asString();
+		if(!valuePaidDesktopsPaidDesktop["ProtocolType"].isNull())
+			paidDesktopsObject.protocolType = valuePaidDesktopsPaidDesktop["ProtocolType"].asString();
+		if(!valuePaidDesktopsPaidDesktop["FotaVersion"].isNull())
+			paidDesktopsObject.fotaVersion = valuePaidDesktopsPaidDesktop["FotaVersion"].asString();
 		auto allEndUserIds = value["EndUserIds"]["endUserIds"];
 		for (auto value : allEndUserIds)
 			paidDesktopsObject.endUserIds.push_back(value.asString());
@@ -128,6 +132,10 @@ void DescribeDesktopsInGroupResult::parse(const std::string &payload)
 			postPaidDesktopsObject.memberEniIp = valuePostPaidDesktopsPostPaidDesktop["MemberEniIp"].asString();
 		if(!valuePostPaidDesktopsPostPaidDesktop["PrimaryEniIp"].isNull())
 			postPaidDesktopsObject.primaryEniIp = valuePostPaidDesktopsPostPaidDesktop["PrimaryEniIp"].asString();
+		if(!valuePostPaidDesktopsPostPaidDesktop["ProtocolType"].isNull())
+			postPaidDesktopsObject.protocolType = valuePostPaidDesktopsPostPaidDesktop["ProtocolType"].asString();
+		if(!valuePostPaidDesktopsPostPaidDesktop["FotaVersion"].isNull())
+			postPaidDesktopsObject.fotaVersion = valuePostPaidDesktopsPostPaidDesktop["FotaVersion"].asString();
 		auto allEndUserIds1 = value["EndUserIds"]["endUserIds"];
 		for (auto value : allEndUserIds1)
 			postPaidDesktopsObject.endUserIds1.push_back(value.asString());

ecd/src/model/DescribeDesktopsRequest.cc

@@ -34,6 +34,23 @@ void DescribeDesktopsRequest::setOfficeSiteId(const std::string &officeSiteId) {
   setParameter(std::string("OfficeSiteId"), officeSiteId);
 }
 
+std::string DescribeDesktopsRequest::getSnapshotPolicyId() const {
+  return snapshotPolicyId_;
+}
+
+void DescribeDesktopsRequest::setSnapshotPolicyId(const std::string &snapshotPolicyId) {
+  snapshotPolicyId_ = snapshotPolicyId;
+  setParameter(std::string("SnapshotPolicyId"), snapshotPolicyId);
+}
+
+std::vector<std::string> DescribeDesktopsRequest::getImageId() const {
+  return imageId_;
+}
+
+void DescribeDesktopsRequest::setImageId(const std::vector<std::string> &imageId) {
+  imageId_ = imageId;
+}
+
 std::string DescribeDesktopsRequest::getDesktopStatus() const {
   return desktopStatus_;
 }
@@ -43,6 +60,15 @@ void DescribeDesktopsRequest::setDesktopStatus(const std::string &desktopStatus)
   setParameter(std::string("DesktopStatus"), desktopStatus);
 }
 
+std::string DescribeDesktopsRequest::getDesktopGroupId() const {
+  return desktopGroupId_;
+}
+
+void DescribeDesktopsRequest::setDesktopGroupId(const std::string &desktopGroupId) {
+  desktopGroupId_ = desktopGroupId;
+  setParameter(std::string("DesktopGroupId"), desktopGroupId);
+}
+
 std::string DescribeDesktopsRequest::getRegionId() const {
   return regionId_;
 }
@@ -61,6 +87,15 @@ void DescribeDesktopsRequest::setNextToken(const std::string &nextToken) {
   setParameter(std::string("NextToken"), nextToken);
 }
 
+bool DescribeDesktopsRequest::getOnlyDesktopGroup() const {
+  return onlyDesktopGroup_;
+}
+
+void DescribeDesktopsRequest::setOnlyDesktopGroup(bool onlyDesktopGroup) {
+  onlyDesktopGroup_ = onlyDesktopGroup;
+  setParameter(std::string("OnlyDesktopGroup"), onlyDesktopGroup ? "true" : "false");
+}
+
 bool DescribeDesktopsRequest::getQueryFotaUpdate() const {
   return queryFotaUpdate_;
 }
@@ -109,6 +144,15 @@ void DescribeDesktopsRequest::setTag(const std::vector<DescribeDesktopsRequest::
   }
 }
 
+std::string DescribeDesktopsRequest::getDesktopType() const {
+  return desktopType_;
+}
+
+void DescribeDesktopsRequest::setDesktopType(const std::string &desktopType) {
+  desktopType_ = desktopType;
+  setParameter(std::string("DesktopType"), desktopType);
+}
+
 std::string DescribeDesktopsRequest::getDesktopName() const {
   return desktopName_;
 }
@@ -180,6 +224,14 @@ void DescribeDesktopsRequest::setMaxResults(int maxResults) {
   setParameter(std::string("MaxResults"), std::to_string(maxResults));
 }
 
+std::vector<std::string> DescribeDesktopsRequest::getOsTypes() const {
+  return osTypes_;
+}
+
+void DescribeDesktopsRequest::setOsTypes(const std::vector<std::string> &osTypes) {
+  osTypes_ = osTypes;
+}
+
 std::string DescribeDesktopsRequest::getProtocolType() const {
   return protocolType_;
 }

ecd/src/model/DescribeDesktopsResult.cc

@@ -133,6 +133,16 @@ void DescribeDesktopsResult::parse(const std::string &payload)
 			desktopsObject.platform = valueDesktopsDesktop["Platform"].asString();
 		if(!valueDesktopsDesktop["SessionType"].isNull())
 			desktopsObject.sessionType = valueDesktopsDesktop["SessionType"].asString();
+		if(!valueDesktopsDesktop["SnapshotPolicyId"].isNull())
+			desktopsObject.snapshotPolicyId = valueDesktopsDesktop["SnapshotPolicyId"].asString();
+		if(!valueDesktopsDesktop["SnapshotPolicyName"].isNull())
+			desktopsObject.snapshotPolicyName = valueDesktopsDesktop["SnapshotPolicyName"].asString();
+		if(!valueDesktopsDesktop["BindAmount"].isNull())
+			desktopsObject.bindAmount = std::stoi(valueDesktopsDesktop["BindAmount"].asString());
+		if(!valueDesktopsDesktop["HibernationOptionsConfigured"].isNull())
+			desktopsObject.hibernationOptionsConfigured = valueDesktopsDesktop["HibernationOptionsConfigured"].asString() == "true";
+		if(!valueDesktopsDesktop["SupportHibernation"].isNull())
+			desktopsObject.supportHibernation = valueDesktopsDesktop["SupportHibernation"].asString() == "true";
 		auto allDisksNode = valueDesktopsDesktop["Disks"]["Disk"];
 		for (auto valueDesktopsDesktopDisksDisk : allDisksNode)
 		{
@@ -184,6 +194,12 @@ void DescribeDesktopsResult::parse(const std::string &payload)
 		auto allManagementFlags = value["ManagementFlags"]["mgtFlag"];
 		for (auto value : allManagementFlags)
 			desktopsObject.managementFlags.push_back(value.asString());
+		auto allPolicyGroupIdList = value["PolicyGroupIdList"]["policyGroupId"];
+		for (auto value : allPolicyGroupIdList)
+			desktopsObject.policyGroupIdList.push_back(value.asString());
+		auto allPolicyGroupNameList = value["PolicyGroupNameList"]["policyGroupName"];
+		for (auto value : allPolicyGroupNameList)
+			desktopsObject.policyGroupNameList.push_back(value.asString());
 		desktops_.push_back(desktopsObject);
 	}
 	if(!value["NextToken"].isNull())

ecd/src/model/DescribeDevicesRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/DescribeDevicesRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeDevicesRequest;
+
+DescribeDevicesRequest::DescribeDevicesRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeDevices") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDevicesRequest::~DescribeDevicesRequest() {}
+
+std::string DescribeDevicesRequest::getClientType() const {
+  return clientType_;
+}
+
+void DescribeDevicesRequest::setClientType(const std::string &clientType) {
+  clientType_ = clientType;
+  setParameter(std::string("ClientType"), clientType);
+}
+
+std::string DescribeDevicesRequest::getUserType() const {
+  return userType_;
+}
+
+void DescribeDevicesRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+std::string DescribeDevicesRequest::getDeviceId() const {
+  return deviceId_;
+}
+
+void DescribeDevicesRequest::setDeviceId(const std::string &deviceId) {
+  deviceId_ = deviceId;
+  setParameter(std::string("DeviceId"), deviceId);
+}
+
+int DescribeDevicesRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeDevicesRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeDevicesRequest::getAdDomain() const {
+  return adDomain_;
+}
+
+void DescribeDevicesRequest::setAdDomain(const std::string &adDomain) {
+  adDomain_ = adDomain;
+  setParameter(std::string("AdDomain"), adDomain);
+}
+
+int DescribeDevicesRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeDevicesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeDevicesRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void DescribeDevicesRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string DescribeDevicesRequest::getDirectoryId() const {
+  return directoryId_;
+}
+
+void DescribeDevicesRequest::setDirectoryId(const std::string &directoryId) {
+  directoryId_ = directoryId;
+  setParameter(std::string("DirectoryId"), directoryId);
+}
+
+std::string DescribeDevicesRequest::getRegion() const {
+  return region_;
+}
+
+void DescribeDevicesRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+

ecd/src/model/DescribeDevicesResult.cc

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/DescribeDevicesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeDevicesResult::DescribeDevicesResult() :
+	ServiceResult()
+{}
+
+DescribeDevicesResult::DescribeDevicesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDevicesResult::~DescribeDevicesResult()
+{}
+
+void DescribeDevicesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDevicesNode = value["Devices"]["DevicesItem"];
+	for (auto valueDevicesDevicesItem : allDevicesNode)
+	{
+		DevicesItem devicesObject;
+		if(!valueDevicesDevicesItem["DeviceId"].isNull())
+			devicesObject.deviceId = valueDevicesDevicesItem["DeviceId"].asString();
+		auto allEndUserListNode = valueDevicesDevicesItem["EndUserList"]["EndUserListItem"];
+		for (auto valueDevicesDevicesItemEndUserListEndUserListItem : allEndUserListNode)
+		{
+			DevicesItem::EndUserListItem endUserListObject;
+			if(!valueDevicesDevicesItemEndUserListEndUserListItem["EndUserId"].isNull())
+				endUserListObject.endUserId = valueDevicesDevicesItemEndUserListEndUserListItem["EndUserId"].asString();
+			if(!valueDevicesDevicesItemEndUserListEndUserListItem["UserType"].isNull())
+				endUserListObject.userType = valueDevicesDevicesItemEndUserListEndUserListItem["UserType"].asString();
+			if(!valueDevicesDevicesItemEndUserListEndUserListItem["DirectoryId"].isNull())
+				endUserListObject.directoryId = valueDevicesDevicesItemEndUserListEndUserListItem["DirectoryId"].asString();
+			if(!valueDevicesDevicesItemEndUserListEndUserListItem["AdDomain"].isNull())
+				endUserListObject.adDomain = valueDevicesDevicesItemEndUserListEndUserListItem["AdDomain"].asString();
+			devicesObject.endUserList.push_back(endUserListObject);
+		}
+		devices_.push_back(devicesObject);
+	}
+
+}
+
+std::vector<DescribeDevicesResult::DevicesItem> DescribeDevicesResult::getDevices()const
+{
+	return devices_;
+}
+

ecd/src/model/DescribeDrivesRequest.cc

@@ -1,62 +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/ecd/model/DescribeDrivesRequest.h>
-
-using AlibabaCloud::Ecd::Model::DescribeDrivesRequest;
-
-DescribeDrivesRequest::DescribeDrivesRequest()
-    : RpcServiceRequest("ecd", "2020-09-30", "DescribeDrives") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDrivesRequest::~DescribeDrivesRequest() {}
-
-std::string DescribeDrivesRequest::getUserId() const {
-  return userId_;
-}
-
-void DescribeDrivesRequest::setUserId(const std::string &userId) {
-  userId_ = userId;
-  setParameter(std::string("UserId"), userId);
-}
-
-std::string DescribeDrivesRequest::getResourceType() const {
-  return resourceType_;
-}
-
-void DescribeDrivesRequest::setResourceType(const std::string &resourceType) {
-  resourceType_ = resourceType;
-  setParameter(std::string("ResourceType"), resourceType);
-}
-
-std::vector<std::string> DescribeDrivesRequest::getDomainIds() const {
-  return domainIds_;
-}
-
-void DescribeDrivesRequest::setDomainIds(const std::vector<std::string> &domainIds) {
-  domainIds_ = domainIds;
-}
-
-std::string DescribeDrivesRequest::getRegionId() const {
-  return regionId_;
-}
-
-void DescribeDrivesRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-

ecd/src/model/DescribeDrivesResult.cc

@@ -1,124 +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/ecd/model/DescribeDrivesResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ecd;
-using namespace AlibabaCloud::Ecd::Model;
-
-DescribeDrivesResult::DescribeDrivesResult() :
-	ServiceResult()
-{}
-
-DescribeDrivesResult::DescribeDrivesResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeDrivesResult::~DescribeDrivesResult()
-{}
-
-void DescribeDrivesResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allDrivesNode = value["Drives"]["Drive"];
-	for (auto valueDrivesDrive : allDrivesNode)
-	{
-		Drive drivesObject;
-		if(!valueDrivesDrive["Id"].isNull())
-			drivesObject.id = valueDrivesDrive["Id"].asString();
-		if(!valueDrivesDrive["GmtCreate"].isNull())
-			drivesObject.gmtCreate = valueDrivesDrive["GmtCreate"].asString();
-		if(!valueDrivesDrive["GmtModified"].isNull())
-			drivesObject.gmtModified = valueDrivesDrive["GmtModified"].asString();
-		if(!valueDrivesDrive["AliUid"].isNull())
-			drivesObject.aliUid = std::stol(valueDrivesDrive["AliUid"].asString());
-		if(!valueDrivesDrive["DomainId"].isNull())
-			drivesObject.domainId = valueDrivesDrive["DomainId"].asString();
-		if(!valueDrivesDrive["ExternalDomainId"].isNull())
-			drivesObject.externalDomainId = valueDrivesDrive["ExternalDomainId"].asString();
-		if(!valueDrivesDrive["DriveId"].isNull())
-			drivesObject.driveId = valueDrivesDrive["DriveId"].asString();
-		if(!valueDrivesDrive["ExternalDriveId"].isNull())
-			drivesObject.externalDriveId = valueDrivesDrive["ExternalDriveId"].asString();
-		if(!valueDrivesDrive["UserId"].isNull())
-			drivesObject.userId = valueDrivesDrive["UserId"].asString();
-		if(!valueDrivesDrive["ExternalUserId"].isNull())
-			drivesObject.externalUserId = valueDrivesDrive["ExternalUserId"].asString();
-		if(!valueDrivesDrive["Name"].isNull())
-			drivesObject.name = valueDrivesDrive["Name"].asString();
-		if(!valueDrivesDrive["Description"].isNull())
-			drivesObject.description = valueDrivesDrive["Description"].asString();
-		if(!valueDrivesDrive["TotalSize"].isNull())
-			drivesObject.totalSize = std::stol(valueDrivesDrive["TotalSize"].asString());
-		if(!valueDrivesDrive["UsedSize"].isNull())
-			drivesObject.usedSize = std::stol(valueDrivesDrive["UsedSize"].asString());
-		if(!valueDrivesDrive["Status"].isNull())
-			drivesObject.status = valueDrivesDrive["Status"].asString();
-		if(!valueDrivesDrive["Type"].isNull())
-			drivesObject.type = valueDrivesDrive["Type"].asString();
-		if(!valueDrivesDrive["ProfileRoaming"].isNull())
-			drivesObject.profileRoaming = valueDrivesDrive["ProfileRoaming"].asString() == "true";
-		if(!valueDrivesDrive["DesktopGroupCount"].isNull())
-			drivesObject.desktopGroupCount = std::stoi(valueDrivesDrive["DesktopGroupCount"].asString());
-		if(!valueDrivesDrive["EnableProfileManagement"].isNull())
-			drivesObject.enableProfileManagement = valueDrivesDrive["EnableProfileManagement"].asString() == "true";
-		auto allDesktopGroupsNode = valueDrivesDrive["DesktopGroups"]["DesktopGroup"];
-		for (auto valueDrivesDriveDesktopGroupsDesktopGroup : allDesktopGroupsNode)
-		{
-			Drive::DesktopGroup desktopGroupsObject;
-			if(!valueDrivesDriveDesktopGroupsDesktopGroup["DesktopGroupId"].isNull())
-				desktopGroupsObject.desktopGroupId = valueDrivesDriveDesktopGroupsDesktopGroup["DesktopGroupId"].asString();
-			if(!valueDrivesDriveDesktopGroupsDesktopGroup["DesktopGroupName"].isNull())
-				desktopGroupsObject.desktopGroupName = valueDrivesDriveDesktopGroupsDesktopGroup["DesktopGroupName"].asString();
-			drivesObject.desktopGroups.push_back(desktopGroupsObject);
-		}
-		drives_.push_back(drivesObject);
-	}
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-
-}
-
-std::string DescribeDrivesResult::getMessage()const
-{
-	return message_;
-}
-
-std::vector<DescribeDrivesResult::Drive> DescribeDrivesResult::getDrives()const
-{
-	return drives_;
-}
-
-std::string DescribeDrivesResult::getCode()const
-{
-	return code_;
-}
-
-bool DescribeDrivesResult::getSuccess()const
-{
-	return success_;
-}
-

ecd/src/model/DescribeFotaTasksResult.cc

@@ -59,6 +59,8 @@ void DescribeFotaTasksResult::parse(const std::string &payload)
 			fotaTasksObject.releaseNote = valueFotaTasksFotaTask["ReleaseNote"].asString();
 		if(!valueFotaTasksFotaTask["Size"].isNull())
 			fotaTasksObject.size = std::stoi(valueFotaTasksFotaTask["Size"].asString());
+		if(!valueFotaTasksFotaTask["PendingCustomImageCount"].isNull())
+			fotaTasksObject.pendingCustomImageCount = std::stoi(valueFotaTasksFotaTask["PendingCustomImageCount"].asString());
 		fotaTasks_.push_back(fotaTasksObject);
 	}
 

ecd/src/model/DescribeImagesRequest.cc

@@ -96,6 +96,15 @@ void DescribeImagesRequest::setImageType(const std::string &imageType) {
   setParameter(std::string("ImageType"), imageType);
 }
 
+std::string DescribeImagesRequest::getSessionType() const {
+  return sessionType_;
+}
+
+void DescribeImagesRequest::setSessionType(const std::string &sessionType) {
+  sessionType_ = sessionType;
+  setParameter(std::string("SessionType"), sessionType);
+}
+
 std::string DescribeImagesRequest::getOsType() const {
   return osType_;
 }

ecd/src/model/DescribeImagesResult.cc

@@ -79,6 +79,10 @@ void DescribeImagesResult::parse(const std::string &payload)
 			imagesObject.sharedCount = std::stoi(valueImagesImage["SharedCount"].asString());
 		if(!valueImagesImage["SessionType"].isNull())
 			imagesObject.sessionType = valueImagesImage["SessionType"].asString();
+		if(!valueImagesImage["UpdateTime"].isNull())
+			imagesObject.updateTime = valueImagesImage["UpdateTime"].asString();
+		if(!valueImagesImage["Platform"].isNull())
+			imagesObject.platform = valueImagesImage["Platform"].asString();
 		auto allSupportedLanguages = value["SupportedLanguages"]["Language"];
 		for (auto value : allSupportedLanguages)
 			imagesObject.supportedLanguages.push_back(value.asString());

ecd/src/model/DescribeInvocationsRequest.cc

@@ -34,6 +34,14 @@ void DescribeInvocationsRequest::setInvokeStatus(const std::string &invokeStatus
   setParameter(std::string("InvokeStatus"), invokeStatus);
 }
 
+std::vector<std::string> DescribeInvocationsRequest::getDesktopIds() const {
+  return desktopIds_;
+}
+
+void DescribeInvocationsRequest::setDesktopIds(const std::vector<std::string> &desktopIds) {
+  desktopIds_ = desktopIds;
+}
+
 bool DescribeInvocationsRequest::getIncludeOutput() const {
   return includeOutput_;
 }

ecd/src/model/DescribeNASFileSystemsRequest.cc

@@ -34,6 +34,15 @@ void DescribeNASFileSystemsRequest::setOfficeSiteId(const std::string &officeSit
   setParameter(std::string("OfficeSiteId"), officeSiteId);
 }
 
+bool DescribeNASFileSystemsRequest::getMatchCompatibleProfile() const {
+  return matchCompatibleProfile_;
+}
+
+void DescribeNASFileSystemsRequest::setMatchCompatibleProfile(bool matchCompatibleProfile) {
+  matchCompatibleProfile_ = matchCompatibleProfile;
+  setParameter(std::string("MatchCompatibleProfile"), matchCompatibleProfile ? "true" : "false");
+}
+
 std::string DescribeNASFileSystemsRequest::getRegionId() const {
   return regionId_;
 }

ecd/src/model/DescribeNASFileSystemsResult.cc

@@ -77,6 +77,20 @@ void DescribeNASFileSystemsResult::parse(const std::string &payload)
 			fileSystemsObject.fileSystemStatus = valueFileSystemsFileSystem["FileSystemStatus"].asString();
 		if(!valueFileSystemsFileSystem["EncryptionEnabled"].isNull())
 			fileSystemsObject.encryptionEnabled = valueFileSystemsFileSystem["EncryptionEnabled"].asString() == "true";
+		if(!valueFileSystemsFileSystem["ProfileCompatible"].isNull())
+			fileSystemsObject.profileCompatible = valueFileSystemsFileSystem["ProfileCompatible"].asString() == "true";
+		if(!valueFileSystemsFileSystem["DomainId"].isNull())
+			fileSystemsObject.domainId = valueFileSystemsFileSystem["DomainId"].asString();
+		auto allDesktopGroupsNode = valueFileSystemsFileSystem["DesktopGroups"]["DesktopGroup"];
+		for (auto valueFileSystemsFileSystemDesktopGroupsDesktopGroup : allDesktopGroupsNode)
+		{
+			FileSystem::DesktopGroup desktopGroupsObject;
+			if(!valueFileSystemsFileSystemDesktopGroupsDesktopGroup["DesktopGroupId"].isNull())
+				desktopGroupsObject.desktopGroupId = valueFileSystemsFileSystemDesktopGroupsDesktopGroup["DesktopGroupId"].asString();
+			if(!valueFileSystemsFileSystemDesktopGroupsDesktopGroup["DesktopGroupName"].isNull())
+				desktopGroupsObject.desktopGroupName = valueFileSystemsFileSystemDesktopGroupsDesktopGroup["DesktopGroupName"].asString();
+			fileSystemsObject.desktopGroups.push_back(desktopGroupsObject);
+		}
 		fileSystems_.push_back(fileSystemsObject);
 	}
 	if(!value["NextToken"].isNull())

ecd/src/model/DescribeNetworkPackagesResult.cc

@@ -53,8 +53,16 @@ void DescribeNetworkPackagesResult::parse(const std::string &payload)
 			networkPackagesObject.createTime = valueNetworkPackagesNetworkPackage["CreateTime"].asString();
 		if(!valueNetworkPackagesNetworkPackage["OfficeSiteId"].isNull())
 			networkPackagesObject.officeSiteId = valueNetworkPackagesNetworkPackage["OfficeSiteId"].asString();
+		if(!valueNetworkPackagesNetworkPackage["PayType"].isNull())
+			networkPackagesObject.payType = valueNetworkPackagesNetworkPackage["PayType"].asString();
 		if(!valueNetworkPackagesNetworkPackage["InternetChargeType"].isNull())
 			networkPackagesObject.internetChargeType = valueNetworkPackagesNetworkPackage["InternetChargeType"].asString();
+		if(!valueNetworkPackagesNetworkPackage["ReservationInternetChargeType"].isNull())
+			networkPackagesObject.reservationInternetChargeType = valueNetworkPackagesNetworkPackage["ReservationInternetChargeType"].asString();
+		if(!valueNetworkPackagesNetworkPackage["ReservationBandwidth"].isNull())
+			networkPackagesObject.reservationBandwidth = std::stoi(valueNetworkPackagesNetworkPackage["ReservationBandwidth"].asString());
+		if(!valueNetworkPackagesNetworkPackage["ReservationActiveTime"].isNull())
+			networkPackagesObject.reservationActiveTime = valueNetworkPackagesNetworkPackage["ReservationActiveTime"].asString();
 		if(!valueNetworkPackagesNetworkPackage["NetworkPackageStatus"].isNull())
 			networkPackagesObject.networkPackageStatus = valueNetworkPackagesNetworkPackage["NetworkPackageStatus"].asString();
 		if(!valueNetworkPackagesNetworkPackage["OfficeSiteName"].isNull())
@@ -65,6 +73,8 @@ void DescribeNetworkPackagesResult::parse(const std::string &payload)
 			networkPackagesObject.vpcSnatPolicy = valueNetworkPackagesNetworkPackage["VpcSnatPolicy"].asString();
 		if(!valueNetworkPackagesNetworkPackage["QosType"].isNull())
 			networkPackagesObject.qosType = valueNetworkPackagesNetworkPackage["QosType"].asString();
+		if(!valueNetworkPackagesNetworkPackage["NgwVersion"].isNull())
+			networkPackagesObject.ngwVersion = valueNetworkPackagesNetworkPackage["NgwVersion"].asString();
 		auto allEipAddresses = value["EipAddresses"]["EipAddress"];
 		for (auto value : allEipAddresses)
 			networkPackagesObject.eipAddresses.push_back(value.asString());

ecd/src/model/DescribeOfficeSitesRequest.cc

@@ -51,6 +51,15 @@ void DescribeOfficeSitesRequest::setEnableInternetAccess(bool enableInternetAcce
   setParameter(std::string("EnableInternetAccess"), enableInternetAccess ? "true" : "false");
 }
 
+bool DescribeOfficeSitesRequest::getVpcNotNone() const {
+  return vpcNotNone_;
+}
+
+void DescribeOfficeSitesRequest::setVpcNotNone(bool vpcNotNone) {
+  vpcNotNone_ = vpcNotNone;
+  setParameter(std::string("VpcNotNone"), vpcNotNone ? "true" : "false");
+}
+
 std::string DescribeOfficeSitesRequest::getRegionId() const {
   return regionId_;
 }

ecd/src/model/DescribeOfficeSitesResult.cc

@@ -109,6 +109,12 @@ void DescribeOfficeSitesResult::parse(const std::string &payload)
 			officeSitesObject.protocolType = valueOfficeSitesOfficeSite["ProtocolType"].asString();
 		if(!valueOfficeSitesOfficeSite["AdHostname"].isNull())
 			officeSitesObject.adHostname = valueOfficeSitesOfficeSite["AdHostname"].asString();
+		if(!valueOfficeSitesOfficeSite["RdsLicenseStatus"].isNull())
+			officeSitesObject.rdsLicenseStatus = valueOfficeSitesOfficeSite["RdsLicenseStatus"].asString();
+		if(!valueOfficeSitesOfficeSite["RdsLicenseAddress"].isNull())
+			officeSitesObject.rdsLicenseAddress = valueOfficeSitesOfficeSite["RdsLicenseAddress"].asString();
+		if(!valueOfficeSitesOfficeSite["RdsLicenseDomainName"].isNull())
+			officeSitesObject.rdsLicenseDomainName = valueOfficeSitesOfficeSite["RdsLicenseDomainName"].asString();
 		auto allADConnectorsNode = valueOfficeSitesOfficeSite["ADConnectors"]["ADConnector"];
 		for (auto valueOfficeSitesOfficeSiteADConnectorsADConnector : allADConnectorsNode)
 		{

ecd/src/model/DescribePolicyGroupsRequest.cc

@@ -43,6 +43,15 @@ void DescribePolicyGroupsRequest::setNextToken(const std::string &nextToken) {
   setParameter(std::string("NextToken"), nextToken);
 }
 
+std::string DescribePolicyGroupsRequest::getScope() const {
+  return scope_;
+}
+
+void DescribePolicyGroupsRequest::setScope(const std::string &scope) {
+  scope_ = scope;
+  setParameter(std::string("Scope"), scope);
+}
+
 int DescribePolicyGroupsRequest::getMaxResults() const {
   return maxResults_;
 }

ecd/src/model/DescribePolicyGroupsResult.cc

@@ -81,6 +81,8 @@ void DescribePolicyGroupsResult::parse(const std::string &payload)
 			describePolicyGroupsObject.localDrive = valueDescribePolicyGroupsDescribePolicyGroup["LocalDrive"].asString();
 		if(!valueDescribePolicyGroupsDescribePolicyGroup["GpuAcceleration"].isNull())
 			describePolicyGroupsObject.gpuAcceleration = valueDescribePolicyGroupsDescribePolicyGroup["GpuAcceleration"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["DomainResolveRuleType"].isNull())
+			describePolicyGroupsObject.domainResolveRuleType = valueDescribePolicyGroupsDescribePolicyGroup["DomainResolveRuleType"].asString();
 		if(!valueDescribePolicyGroupsDescribePolicyGroup["Recording"].isNull())
 			describePolicyGroupsObject.recording = valueDescribePolicyGroupsDescribePolicyGroup["Recording"].asString();
 		if(!valueDescribePolicyGroupsDescribePolicyGroup["RecordingStartTime"].isNull())
@@ -103,6 +105,52 @@ void DescribePolicyGroupsResult::parse(const std::string &payload)
 			describePolicyGroupsObject.recordContentExpires = std::stol(valueDescribePolicyGroupsDescribePolicyGroup["RecordContentExpires"].asString());
 		if(!valueDescribePolicyGroupsDescribePolicyGroup["RemoteCoordinate"].isNull())
 			describePolicyGroupsObject.remoteCoordinate = valueDescribePolicyGroupsDescribePolicyGroup["RemoteCoordinate"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["RecordingDuration"].isNull())
+			describePolicyGroupsObject.recordingDuration = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["RecordingDuration"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["Scope"].isNull())
+			describePolicyGroupsObject.scope = valueDescribePolicyGroupsDescribePolicyGroup["Scope"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["RecordingAudio"].isNull())
+			describePolicyGroupsObject.recordingAudio = valueDescribePolicyGroupsDescribePolicyGroup["RecordingAudio"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["InternetCommunicationProtocol"].isNull())
+			describePolicyGroupsObject.internetCommunicationProtocol = valueDescribePolicyGroupsDescribePolicyGroup["InternetCommunicationProtocol"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["VideoRedirect"].isNull())
+			describePolicyGroupsObject.videoRedirect = valueDescribePolicyGroupsDescribePolicyGroup["VideoRedirect"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["WatermarkTransparencyValue"].isNull())
+			describePolicyGroupsObject.watermarkTransparencyValue = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["WatermarkTransparencyValue"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["WatermarkColor"].isNull())
+			describePolicyGroupsObject.watermarkColor = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["WatermarkColor"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["WatermarkFontSize"].isNull())
+			describePolicyGroupsObject.watermarkFontSize = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["WatermarkFontSize"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["WatermarkFontStyle"].isNull())
+			describePolicyGroupsObject.watermarkFontStyle = valueDescribePolicyGroupsDescribePolicyGroup["WatermarkFontStyle"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["WatermarkDegree"].isNull())
+			describePolicyGroupsObject.watermarkDegree = valueDescribePolicyGroupsDescribePolicyGroup["WatermarkDegree"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["WatermarkRowAmount"].isNull())
+			describePolicyGroupsObject.watermarkRowAmount = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["WatermarkRowAmount"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["EndUserApplyAdminCoordinate"].isNull())
+			describePolicyGroupsObject.endUserApplyAdminCoordinate = valueDescribePolicyGroupsDescribePolicyGroup["EndUserApplyAdminCoordinate"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["EndUserGroupCoordinate"].isNull())
+			describePolicyGroupsObject.endUserGroupCoordinate = valueDescribePolicyGroupsDescribePolicyGroup["EndUserGroupCoordinate"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["CpuProtectedMode"].isNull())
+			describePolicyGroupsObject.cpuProtectedMode = valueDescribePolicyGroupsDescribePolicyGroup["CpuProtectedMode"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["CpuRateLimit"].isNull())
+			describePolicyGroupsObject.cpuRateLimit = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["CpuRateLimit"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["CpuSampleDuration"].isNull())
+			describePolicyGroupsObject.cpuSampleDuration = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["CpuSampleDuration"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["CpuSingleRateLimit"].isNull())
+			describePolicyGroupsObject.cpuSingleRateLimit = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["CpuSingleRateLimit"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["CpuDownGradeDuration"].isNull())
+			describePolicyGroupsObject.cpuDownGradeDuration = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["CpuDownGradeDuration"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["MemoryProtectedMode"].isNull())
+			describePolicyGroupsObject.memoryProtectedMode = valueDescribePolicyGroupsDescribePolicyGroup["MemoryProtectedMode"].asString();
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["MemoryRateLimit"].isNull())
+			describePolicyGroupsObject.memoryRateLimit = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["MemoryRateLimit"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["MemorySampleDuration"].isNull())
+			describePolicyGroupsObject.memorySampleDuration = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["MemorySampleDuration"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["MemorySingleRateLimit"].isNull())
+			describePolicyGroupsObject.memorySingleRateLimit = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["MemorySingleRateLimit"].asString());
+		if(!valueDescribePolicyGroupsDescribePolicyGroup["MemoryDownGradeDuration"].isNull())
+			describePolicyGroupsObject.memoryDownGradeDuration = std::stoi(valueDescribePolicyGroupsDescribePolicyGroup["MemoryDownGradeDuration"].asString());
 		auto allAuthorizeSecurityPolicyRulesNode = valueDescribePolicyGroupsDescribePolicyGroup["AuthorizeSecurityPolicyRules"]["AuthorizeSecurityPolicyRule"];
 		for (auto valueDescribePolicyGroupsDescribePolicyGroupAuthorizeSecurityPolicyRulesAuthorizeSecurityPolicyRule : allAuthorizeSecurityPolicyRulesNode)
 		{
@@ -163,9 +211,42 @@ void DescribePolicyGroupsResult::parse(const std::string &payload)
 				usbSupplyRedirectRuleObject.usbRuleType = std::stol(valueDescribePolicyGroupsDescribePolicyGroupUsbSupplyRedirectRuleUsbSupplyRedirectRuleItem["UsbRuleType"].asString());
 			describePolicyGroupsObject.usbSupplyRedirectRule.push_back(usbSupplyRedirectRuleObject);
 		}
+		auto allDomainResolveRuleNode = valueDescribePolicyGroupsDescribePolicyGroup["DomainResolveRule"]["DomainResolveRuleItem"];
+		for (auto valueDescribePolicyGroupsDescribePolicyGroupDomainResolveRuleDomainResolveRuleItem : allDomainResolveRuleNode)
+		{
+			DescribePolicyGroup::DomainResolveRuleItem domainResolveRuleObject;
+			if(!valueDescribePolicyGroupsDescribePolicyGroupDomainResolveRuleDomainResolveRuleItem["Domain"].isNull())
+				domainResolveRuleObject.domain = valueDescribePolicyGroupsDescribePolicyGroupDomainResolveRuleDomainResolveRuleItem["Domain"].asString();
+			if(!valueDescribePolicyGroupsDescribePolicyGroupDomainResolveRuleDomainResolveRuleItem["Policy"].isNull())
+				domainResolveRuleObject.policy = valueDescribePolicyGroupsDescribePolicyGroupDomainResolveRuleDomainResolveRuleItem["Policy"].asString();
+			if(!valueDescribePolicyGroupsDescribePolicyGroupDomainResolveRuleDomainResolveRuleItem["Description"].isNull())
+				domainResolveRuleObject.description = valueDescribePolicyGroupsDescribePolicyGroupDomainResolveRuleDomainResolveRuleItem["Description"].asString();
+			describePolicyGroupsObject.domainResolveRule.push_back(domainResolveRuleObject);
+		}
+		auto allNetRedirectRuleNode = valueDescribePolicyGroupsDescribePolicyGroup["NetRedirectRule"]["NetRedirectRuleItem"];
+		for (auto valueDescribePolicyGroupsDescribePolicyGroupNetRedirectRuleNetRedirectRuleItem : allNetRedirectRuleNode)
+		{
+			DescribePolicyGroup::NetRedirectRuleItem netRedirectRuleObject;
+			if(!valueDescribePolicyGroupsDescribePolicyGroupNetRedirectRuleNetRedirectRuleItem["Domain"].isNull())
+				netRedirectRuleObject.domain = valueDescribePolicyGroupsDescribePolicyGroupNetRedirectRuleNetRedirectRuleItem["Domain"].asString();
+			if(!valueDescribePolicyGroupsDescribePolicyGroupNetRedirectRuleNetRedirectRuleItem["RuleType"].isNull())
+				netRedirectRuleObject.ruleType = valueDescribePolicyGroupsDescribePolicyGroupNetRedirectRuleNetRedirectRuleItem["RuleType"].asString();
+			if(!valueDescribePolicyGroupsDescribePolicyGroupNetRedirectRuleNetRedirectRuleItem["Policy"].isNull())
+				netRedirectRuleObject.policy = valueDescribePolicyGroupsDescribePolicyGroupNetRedirectRuleNetRedirectRuleItem["Policy"].asString();
+			describePolicyGroupsObject.netRedirectRule.push_back(netRedirectRuleObject);
+		}
 		auto allPreemptLoginUsers = value["PreemptLoginUsers"]["PreemptLoginUser"];
 		for (auto value : allPreemptLoginUsers)
 			describePolicyGroupsObject.preemptLoginUsers.push_back(value.asString());
+		auto allScopeValue = value["ScopeValue"]["scopeValue"];
+		for (auto value : allScopeValue)
+			describePolicyGroupsObject.scopeValue.push_back(value.asString());
+		auto allCpuProcessors = value["CpuProcessors"]["cpuProcessor"];
+		for (auto value : allCpuProcessors)
+			describePolicyGroupsObject.cpuProcessors.push_back(value.asString());
+		auto allMemoryProcessors = value["MemoryProcessors"]["memoryProcessor"];
+		for (auto value : allMemoryProcessors)
+			describePolicyGroupsObject.memoryProcessors.push_back(value.asString());
 		describePolicyGroups_.push_back(describePolicyGroupsObject);
 	}
 	if(!value["NextToken"].isNull())

ecd/src/model/DescribeSnapshotsRequest.cc

@@ -34,6 +34,24 @@ void DescribeSnapshotsRequest::setSnapshotId(const std::string &snapshotId) {
   setParameter(std::string("SnapshotId"), snapshotId);
 }
 
+std::string DescribeSnapshotsRequest::getSnapshotName() const {
+  return snapshotName_;
+}
+
+void DescribeSnapshotsRequest::setSnapshotName(const std::string &snapshotName) {
+  snapshotName_ = snapshotName;
+  setParameter(std::string("SnapshotName"), snapshotName);
+}
+
+std::string DescribeSnapshotsRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeSnapshotsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
 std::string DescribeSnapshotsRequest::getRegionId() const {
   return regionId_;
 }
@@ -52,15 +70,6 @@ void DescribeSnapshotsRequest::setNextToken(const std::string &nextToken) {
   setParameter(std::string("NextToken"), nextToken);
 }
 
-int DescribeSnapshotsRequest::getMaxResults() const {
-  return maxResults_;
-}
-
-void DescribeSnapshotsRequest::setMaxResults(int maxResults) {
-  maxResults_ = maxResults;
-  setParameter(std::string("MaxResults"), std::to_string(maxResults));
-}
-
 std::string DescribeSnapshotsRequest::getDesktopId() const {
   return desktopId_;
 }
@@ -70,3 +79,57 @@ void DescribeSnapshotsRequest::setDesktopId(const std::string &desktopId) {
   setParameter(std::string("DesktopId"), desktopId);
 }
 
+std::string DescribeSnapshotsRequest::getDesktopName() const {
+  return desktopName_;
+}
+
+void DescribeSnapshotsRequest::setDesktopName(const std::string &desktopName) {
+  desktopName_ = desktopName;
+  setParameter(std::string("DesktopName"), desktopName);
+}
+
+std::string DescribeSnapshotsRequest::getCreator() const {
+  return creator_;
+}
+
+void DescribeSnapshotsRequest::setCreator(const std::string &creator) {
+  creator_ = creator;
+  setParameter(std::string("Creator"), creator);
+}
+
+std::string DescribeSnapshotsRequest::getSourceDiskType() const {
+  return sourceDiskType_;
+}
+
+void DescribeSnapshotsRequest::setSourceDiskType(const std::string &sourceDiskType) {
+  sourceDiskType_ = sourceDiskType;
+  setParameter(std::string("SourceDiskType"), sourceDiskType);
+}
+
+std::string DescribeSnapshotsRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeSnapshotsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+std::string DescribeSnapshotsRequest::getSnapshotType() const {
+  return snapshotType_;
+}
+
+void DescribeSnapshotsRequest::setSnapshotType(const std::string &snapshotType) {
+  snapshotType_ = snapshotType;
+  setParameter(std::string("SnapshotType"), snapshotType);
+}
+
+int DescribeSnapshotsRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeSnapshotsRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

ecd/src/model/DescribeSnapshotsResult.cc

@@ -65,12 +65,20 @@ void DescribeSnapshotsResult::parse(const std::string &payload)
 			snapshotsObject.sourceDiskType = valueSnapshotsSnapshot["SourceDiskType"].asString();
 		if(!valueSnapshotsSnapshot["DesktopId"].isNull())
 			snapshotsObject.desktopId = valueSnapshotsSnapshot["DesktopId"].asString();
+		if(!valueSnapshotsSnapshot["DesktopName"].isNull())
+			snapshotsObject.desktopName = valueSnapshotsSnapshot["DesktopName"].asString();
+		if(!valueSnapshotsSnapshot["DesktopStatus"].isNull())
+			snapshotsObject.desktopStatus = valueSnapshotsSnapshot["DesktopStatus"].asString();
+		if(!valueSnapshotsSnapshot["Creator"].isNull())
+			snapshotsObject.creator = valueSnapshotsSnapshot["Creator"].asString();
+		if(!valueSnapshotsSnapshot["ProtocolType"].isNull())
+			snapshotsObject.protocolType = valueSnapshotsSnapshot["ProtocolType"].asString();
 		if(!valueSnapshotsSnapshot["VolumeEncryptionEnabled"].isNull())
 			snapshotsObject.volumeEncryptionEnabled = valueSnapshotsSnapshot["VolumeEncryptionEnabled"].asString() == "true";
 		if(!valueSnapshotsSnapshot["VolumeEncryptionKey"].isNull())
 			snapshotsObject.volumeEncryptionKey = valueSnapshotsSnapshot["VolumeEncryptionKey"].asString();
-		if(!valueSnapshotsSnapshot["ProtocolType"].isNull())
-			snapshotsObject.protocolType = valueSnapshotsSnapshot["ProtocolType"].asString();
+		if(!valueSnapshotsSnapshot["DeletionTime"].isNull())
+			snapshotsObject.deletionTime = valueSnapshotsSnapshot["DeletionTime"].asString();
 		snapshots_.push_back(snapshotsObject);
 	}
 	if(!value["NextToken"].isNull())

ecd/src/model/DescribeSuspEventsResult.cc

@@ -85,6 +85,8 @@ void DescribeSuspEventsResult::parse(const std::string &payload)
 			suspEventsObject.level = valueSuspEventsSuspEvent["Level"].asString();
 		if(!valueSuspEventsSuspEvent["Id"].isNull())
 			suspEventsObject.id = std::stol(valueSuspEventsSuspEvent["Id"].asString());
+		if(!valueSuspEventsSuspEvent["DesktopGroupId"].isNull())
+			suspEventsObject.desktopGroupId = valueSuspEventsSuspEvent["DesktopGroupId"].asString();
 		auto allDetailsNode = valueSuspEventsSuspEvent["Details"]["Detail"];
 		for (auto valueSuspEventsSuspEventDetailsDetail : allDetailsNode)
 		{

ecd/src/model/DescribeUserProfilePathRulesRequest.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/ecd/model/DescribeUserProfilePathRulesRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeUserProfilePathRulesRequest;
+
+DescribeUserProfilePathRulesRequest::DescribeUserProfilePathRulesRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeUserProfilePathRules") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeUserProfilePathRulesRequest::~DescribeUserProfilePathRulesRequest() {}
+
+std::string DescribeUserProfilePathRulesRequest::getRuleType() const {
+  return ruleType_;
+}
+
+void DescribeUserProfilePathRulesRequest::setRuleType(const std::string &ruleType) {
+  ruleType_ = ruleType;
+  setParameter(std::string("RuleType"), ruleType);
+}
+
+std::string DescribeUserProfilePathRulesRequest::getDesktopGroupId() const {
+  return desktopGroupId_;
+}
+
+void DescribeUserProfilePathRulesRequest::setDesktopGroupId(const std::string &desktopGroupId) {
+  desktopGroupId_ = desktopGroupId;
+  setParameter(std::string("DesktopGroupId"), desktopGroupId);
+}
+
+std::string DescribeUserProfilePathRulesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeUserProfilePathRulesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

ecd/src/model/DescribeUserProfilePathRulesResult.cc

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/DescribeUserProfilePathRulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeUserProfilePathRulesResult::DescribeUserProfilePathRulesResult() :
+	ServiceResult()
+{}
+
+DescribeUserProfilePathRulesResult::DescribeUserProfilePathRulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeUserProfilePathRulesResult::~DescribeUserProfilePathRulesResult()
+{}
+
+void DescribeUserProfilePathRulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto userProfilePathRuleNode = value["UserProfilePathRule"];
+	if(!userProfilePathRuleNode["DesktopGroupId"].isNull())
+		userProfilePathRule_.desktopGroupId = userProfilePathRuleNode["DesktopGroupId"].asString();
+	if(!userProfilePathRuleNode["UserProfileRuleType"].isNull())
+		userProfilePathRule_.userProfileRuleType = userProfilePathRuleNode["UserProfileRuleType"].asString();
+	auto allRulesNode = userProfilePathRuleNode["Rules"]["upmPathRules"];
+	for (auto userProfilePathRuleNodeRulesupmPathRules : allRulesNode)
+	{
+		UserProfilePathRule::UpmPathRules upmPathRulesObject;
+		auto allWhitePathsNode = userProfilePathRuleNodeRulesupmPathRules["WhitePaths"]["whiteList"];
+		for (auto userProfilePathRuleNodeRulesupmPathRulesWhitePathswhiteList : allWhitePathsNode)
+		{
+			UserProfilePathRule::UpmPathRules::WhiteList whitePathsObject;
+			if(!userProfilePathRuleNodeRulesupmPathRulesWhitePathswhiteList["Path"].isNull())
+				whitePathsObject.path = userProfilePathRuleNodeRulesupmPathRulesWhitePathswhiteList["Path"].asString();
+			if(!userProfilePathRuleNodeRulesupmPathRulesWhitePathswhiteList["Type"].isNull())
+				whitePathsObject.type = userProfilePathRuleNodeRulesupmPathRulesWhitePathswhiteList["Type"].asString();
+			upmPathRulesObject.whitePaths.push_back(whitePathsObject);
+		}
+		auto blackPathNode = value["BlackPath"];
+		if(!blackPathNode["Path"].isNull())
+			upmPathRulesObject.blackPath.path = blackPathNode["Path"].asString();
+		if(!blackPathNode["Type"].isNull())
+			upmPathRulesObject.blackPath.type = blackPathNode["Type"].asString();
+		userProfilePathRule_.rules.push_back(upmPathRulesObject);
+	}
+
+}
+
+DescribeUserProfilePathRulesResult::UserProfilePathRule DescribeUserProfilePathRulesResult::getUserProfilePathRule()const
+{
+	return userProfilePathRule_;
+}
+

ecd/src/model/DescribeUsersInGroupRequest.cc

@@ -25,6 +25,14 @@ DescribeUsersInGroupRequest::DescribeUsersInGroupRequest()
 
 DescribeUsersInGroupRequest::~DescribeUsersInGroupRequest() {}
 
+std::vector<std::string> DescribeUsersInGroupRequest::getEndUserIds() const {
+  return endUserIds_;
+}
+
+void DescribeUsersInGroupRequest::setEndUserIds(const std::vector<std::string> &endUserIds) {
+  endUserIds_ = endUserIds;
+}
+
 int DescribeUsersInGroupRequest::getConnectState() const {
   return connectState_;
 }

ecd/src/model/DetachEndUserRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/ecd/model/DetachEndUserRequest.h>
+
+using AlibabaCloud::Ecd::Model::DetachEndUserRequest;
+
+DetachEndUserRequest::DetachEndUserRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DetachEndUser") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetachEndUserRequest::~DetachEndUserRequest() {}
+
+std::string DetachEndUserRequest::getClientType() const {
+  return clientType_;
+}
+
+void DetachEndUserRequest::setClientType(const std::string &clientType) {
+  clientType_ = clientType;
+  setParameter(std::string("ClientType"), clientType);
+}
+
+std::string DetachEndUserRequest::getDeviceId() const {
+  return deviceId_;
+}
+
+void DetachEndUserRequest::setDeviceId(const std::string &deviceId) {
+  deviceId_ = deviceId;
+  setParameter(std::string("DeviceId"), deviceId);
+}
+
+std::string DetachEndUserRequest::getAdDomain() const {
+  return adDomain_;
+}
+
+void DetachEndUserRequest::setAdDomain(const std::string &adDomain) {
+  adDomain_ = adDomain;
+  setParameter(std::string("AdDomain"), adDomain);
+}
+
+std::string DetachEndUserRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void DetachEndUserRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string DetachEndUserRequest::getDirectoryId() const {
+  return directoryId_;
+}
+
+void DetachEndUserRequest::setDirectoryId(const std::string &directoryId) {
+  directoryId_ = directoryId;
+  setParameter(std::string("DirectoryId"), directoryId);
+}
+
+std::string DetachEndUserRequest::getRegion() const {
+  return region_;
+}
+
+void DetachEndUserRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+

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

ecd/src/model/ExportClientEventsRequest.cc

@@ -123,3 +123,12 @@ void ExportClientEventsRequest::setEventType(const std::string &eventType) {
   setParameter(std::string("EventType"), eventType);
 }
 
+std::string ExportClientEventsRequest::getLangType() const {
+  return langType_;
+}
+
+void ExportClientEventsRequest::setLangType(const std::string &langType) {
+  langType_ = langType;
+  setParameter(std::string("LangType"), langType);
+}
+

ecd/src/model/GetConnectionTicketRequest.cc

@@ -43,6 +43,15 @@ void GetConnectionTicketRequest::setUuid(const std::string &uuid) {
   setParameter(std::string("Uuid"), uuid);
 }
 
+std::string GetConnectionTicketRequest::getCommandContent() const {
+  return commandContent_;
+}
+
+void GetConnectionTicketRequest::setCommandContent(const std::string &commandContent) {
+  commandContent_ = commandContent;
+  setParameter(std::string("CommandContent"), commandContent);
+}
+
 std::string GetConnectionTicketRequest::getPassword() const {
   return password_;
 }

ecd/src/model/GetDesktopGroupDetailResult.cc

@@ -126,6 +126,12 @@ void GetDesktopGroupDetailResult::parse(const std::string &payload)
 		desktops_.nasFileSystemID = desktopsNode["NasFileSystemID"].asString();
 	if(!desktopsNode["NasFileSystemName"].isNull())
 		desktops_.nasFileSystemName = desktopsNode["NasFileSystemName"].asString();
+	if(!desktopsNode["TimingStrategyInfo"].isNull())
+		desktops_.timingStrategyInfo = desktopsNode["TimingStrategyInfo"].asString();
+	if(!desktopsNode["BuyDesktopsCount"].isNull())
+		desktops_.buyDesktopsCount = std::stoi(desktopsNode["BuyDesktopsCount"].asString());
+	if(!desktopsNode["ImageId"].isNull())
+		desktops_.imageId = desktopsNode["ImageId"].asString();
 	auto allTimerInfosNode = desktopsNode["TimerInfos"]["TimerInfo"];
 	for (auto desktopsNodeTimerInfosTimerInfo : allTimerInfosNode)
 	{
@@ -140,6 +146,34 @@ void GetDesktopGroupDetailResult::parse(const std::string &payload)
 			timerInfoObject.forced = desktopsNodeTimerInfosTimerInfo["Forced"].asString() == "true";
 		desktops_.timerInfos.push_back(timerInfoObject);
 	}
+	auto allScaleTimerInfosNode = desktopsNode["ScaleTimerInfos"]["ScaleTimerInfo"];
+	for (auto desktopsNodeScaleTimerInfosScaleTimerInfo : allScaleTimerInfosNode)
+	{
+		Desktops::ScaleTimerInfo scaleTimerInfoObject;
+		if(!desktopsNodeScaleTimerInfosScaleTimerInfo["Type"].isNull())
+			scaleTimerInfoObject.type = desktopsNodeScaleTimerInfosScaleTimerInfo["Type"].asString();
+		if(!desktopsNodeScaleTimerInfosScaleTimerInfo["Cron"].isNull())
+			scaleTimerInfoObject.cron = desktopsNodeScaleTimerInfosScaleTimerInfo["Cron"].asString();
+		if(!desktopsNodeScaleTimerInfosScaleTimerInfo["LoadPolicy"].isNull())
+			scaleTimerInfoObject.loadPolicy = std::stoi(desktopsNodeScaleTimerInfosScaleTimerInfo["LoadPolicy"].asString());
+		if(!desktopsNodeScaleTimerInfosScaleTimerInfo["BuyResAmount"].isNull())
+			scaleTimerInfoObject.buyResAmount = std::stoi(desktopsNodeScaleTimerInfosScaleTimerInfo["BuyResAmount"].asString());
+		if(!desktopsNodeScaleTimerInfosScaleTimerInfo["MinResAmount"].isNull())
+			scaleTimerInfoObject.minResAmount = std::stoi(desktopsNodeScaleTimerInfosScaleTimerInfo["MinResAmount"].asString());
+		if(!desktopsNodeScaleTimerInfosScaleTimerInfo["MaxResAmount"].isNull())
+			scaleTimerInfoObject.maxResAmount = std::stoi(desktopsNodeScaleTimerInfosScaleTimerInfo["MaxResAmount"].asString());
+		if(!desktopsNodeScaleTimerInfosScaleTimerInfo["KeepDuration"].isNull())
+			scaleTimerInfoObject.keepDuration = std::stol(desktopsNodeScaleTimerInfosScaleTimerInfo["KeepDuration"].asString());
+		if(!desktopsNodeScaleTimerInfosScaleTimerInfo["RatioThreshold"].isNull())
+			scaleTimerInfoObject.ratioThreshold = std::stof(desktopsNodeScaleTimerInfosScaleTimerInfo["RatioThreshold"].asString());
+		desktops_.scaleTimerInfos.push_back(scaleTimerInfoObject);
+	}
+		auto allPolicyGroupIds = desktopsNode["PolicyGroupIds"]["policyGroupId"];
+		for (auto value : allPolicyGroupIds)
+			desktops_.policyGroupIds.push_back(value.asString());
+		auto allPolicyGroupNames = desktopsNode["PolicyGroupNames"]["policyGroupName"];
+		for (auto value : allPolicyGroupNames)
+			desktops_.policyGroupNames.push_back(value.asString());
 
 }
 

ecd/src/model/HibernateDesktopsRequest.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/ecd/model/HibernateDesktopsRequest.h>
+
+using AlibabaCloud::Ecd::Model::HibernateDesktopsRequest;
+
+HibernateDesktopsRequest::HibernateDesktopsRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "HibernateDesktops") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+HibernateDesktopsRequest::~HibernateDesktopsRequest() {}
+
+std::string HibernateDesktopsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void HibernateDesktopsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> HibernateDesktopsRequest::getDesktopId() const {
+  return desktopId_;
+}
+
+void HibernateDesktopsRequest::setDesktopId(const std::vector<std::string> &desktopId) {
+  desktopId_ = desktopId;
+}
+

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

ecd/src/model/ListCdsFilesRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * 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/ecd/model/ListCdsFilesRequest.h>
+
+using AlibabaCloud::Ecd::Model::ListCdsFilesRequest;
+
+ListCdsFilesRequest::ListCdsFilesRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ListCdsFiles") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListCdsFilesRequest::~ListCdsFilesRequest() {}
+
+std::string ListCdsFilesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListCdsFilesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListCdsFilesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListCdsFilesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListCdsFilesRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void ListCdsFilesRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string ListCdsFilesRequest::getRootId() const {
+  return rootId_;
+}
+
+void ListCdsFilesRequest::setRootId(const std::string &rootId) {
+  rootId_ = rootId;
+  setParameter(std::string("RootId"), rootId);
+}
+
+std::string ListCdsFilesRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void ListCdsFilesRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string ListCdsFilesRequest::getParentFileId() const {
+  return parentFileId_;
+}
+
+void ListCdsFilesRequest::setParentFileId(const std::string &parentFileId) {
+  parentFileId_ = parentFileId;
+  setParameter(std::string("ParentFileId"), parentFileId);
+}
+
+std::string ListCdsFilesRequest::getFileIds() const {
+  return fileIds_;
+}
+
+void ListCdsFilesRequest::setFileIds(const std::string &fileIds) {
+  fileIds_ = fileIds;
+  setParameter(std::string("FileIds"), fileIds);
+}
+
+int ListCdsFilesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListCdsFilesRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string ListCdsFilesRequest::getOrderType() const {
+  return orderType_;
+}
+
+void ListCdsFilesRequest::setOrderType(const std::string &orderType) {
+  orderType_ = orderType;
+  setParameter(std::string("OrderType"), orderType);
+}
+
+std::string ListCdsFilesRequest::getStatus() const {
+  return status_;
+}
+
+void ListCdsFilesRequest::setStatus(const std::string &status) {
+  status_ = status;
+  setParameter(std::string("Status"), status);
+}
+

ecd/src/model/ListCdsFilesResult.cc

@@ -0,0 +1,142 @@
+/*
+ * 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/ecd/model/ListCdsFilesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+ListCdsFilesResult::ListCdsFilesResult() :
+	ServiceResult()
+{}
+
+ListCdsFilesResult::ListCdsFilesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListCdsFilesResult::~ListCdsFilesResult()
+{}
+
+void ListCdsFilesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFileModelsNode = value["FileModels"]["fileModel"];
+	for (auto valueFileModelsfileModel : allFileModelsNode)
+	{
+		FileModel fileModelsObject;
+		if(!valueFileModelsfileModel["Status"].isNull())
+			fileModelsObject.status = valueFileModelsfileModel["Status"].asString();
+		if(!valueFileModelsfileModel["ContentType"].isNull())
+			fileModelsObject.contentType = valueFileModelsfileModel["ContentType"].asString();
+		if(!valueFileModelsfileModel["FileType"].isNull())
+			fileModelsObject.fileType = valueFileModelsfileModel["FileType"].asString();
+		if(!valueFileModelsfileModel["StorageType"].isNull())
+			fileModelsObject.storageType = valueFileModelsfileModel["StorageType"].asString();
+		if(!valueFileModelsfileModel["FileExtension"].isNull())
+			fileModelsObject.fileExtension = valueFileModelsfileModel["FileExtension"].asString();
+		if(!valueFileModelsfileModel["DomainId"].isNull())
+			fileModelsObject.domainId = valueFileModelsfileModel["DomainId"].asString();
+		if(!valueFileModelsfileModel["FileId"].isNull())
+			fileModelsObject.fileId = valueFileModelsfileModel["FileId"].asString();
+		if(!valueFileModelsfileModel["Creator"].isNull())
+			fileModelsObject.creator = valueFileModelsfileModel["Creator"].asString();
+		if(!valueFileModelsfileModel["OpenTime"].isNull())
+			fileModelsObject.openTime = valueFileModelsfileModel["OpenTime"].asString();
+		if(!valueFileModelsfileModel["ParentId"].isNull())
+			fileModelsObject.parentId = valueFileModelsfileModel["ParentId"].asString();
+		if(!valueFileModelsfileModel["Modifier"].isNull())
+			fileModelsObject.modifier = valueFileModelsfileModel["Modifier"].asString();
+		if(!valueFileModelsfileModel["Description"].isNull())
+			fileModelsObject.description = valueFileModelsfileModel["Description"].asString();
+		if(!valueFileModelsfileModel["Name"].isNull())
+			fileModelsObject.name = valueFileModelsfileModel["Name"].asString();
+		if(!valueFileModelsfileModel["DownloadUrl"].isNull())
+			fileModelsObject.downloadUrl = valueFileModelsfileModel["DownloadUrl"].asString();
+		if(!valueFileModelsfileModel["Sha1"].isNull())
+			fileModelsObject.sha1 = valueFileModelsfileModel["Sha1"].asString();
+		if(!valueFileModelsfileModel["OpenTimeStamp"].isNull())
+			fileModelsObject.openTimeStamp = std::stol(valueFileModelsfileModel["OpenTimeStamp"].asString());
+		if(!valueFileModelsfileModel["RegionId"].isNull())
+			fileModelsObject.regionId = valueFileModelsfileModel["RegionId"].asString();
+		if(!valueFileModelsfileModel["RootId"].isNull())
+			fileModelsObject.rootId = valueFileModelsfileModel["RootId"].asString();
+		if(!valueFileModelsfileModel["FilePath"].isNull())
+			fileModelsObject.filePath = valueFileModelsfileModel["FilePath"].asString();
+		if(!valueFileModelsfileModel["Size"].isNull())
+			fileModelsObject.size = std::stol(valueFileModelsfileModel["Size"].asString());
+		if(!valueFileModelsfileModel["Category"].isNull())
+			fileModelsObject.category = valueFileModelsfileModel["Category"].asString();
+		if(!valueFileModelsfileModel["Md5"].isNull())
+			fileModelsObject.md5 = valueFileModelsfileModel["Md5"].asString();
+		if(!valueFileModelsfileModel["DriveId"].isNull())
+			fileModelsObject.driveId = valueFileModelsfileModel["DriveId"].asString();
+		if(!valueFileModelsfileModel["Thumbnail"].isNull())
+			fileModelsObject.thumbnail = valueFileModelsfileModel["Thumbnail"].asString();
+		if(!valueFileModelsfileModel["CreateTime"].isNull())
+			fileModelsObject.createTime = valueFileModelsfileModel["CreateTime"].asString();
+		if(!valueFileModelsfileModel["ModifiedTime"].isNull())
+			fileModelsObject.modifiedTime = valueFileModelsfileModel["ModifiedTime"].asString();
+		fileModels_.push_back(fileModelsObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["Count"].isNull())
+		count_ = value["Count"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string ListCdsFilesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListCdsFilesResult::getMessage()const
+{
+	return message_;
+}
+
+std::string ListCdsFilesResult::getCount()const
+{
+	return count_;
+}
+
+std::vector<ListCdsFilesResult::FileModel> ListCdsFilesResult::getFileModels()const
+{
+	return fileModels_;
+}
+
+std::string ListCdsFilesResult::getCode()const
+{
+	return code_;
+}
+
+bool ListCdsFilesResult::getSuccess()const
+{
+	return success_;
+}
+

ecd/src/model/ListFilePermissionRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/ListFilePermissionRequest.h>
+
+using AlibabaCloud::Ecd::Model::ListFilePermissionRequest;
+
+ListFilePermissionRequest::ListFilePermissionRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ListFilePermission") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListFilePermissionRequest::~ListFilePermissionRequest() {}
+
+std::string ListFilePermissionRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void ListFilePermissionRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string ListFilePermissionRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListFilePermissionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListFilePermissionRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void ListFilePermissionRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string ListFilePermissionRequest::getFileId() const {
+  return fileId_;
+}
+
+void ListFilePermissionRequest::setFileId(const std::string &fileId) {
+  fileId_ = fileId;
+  setParameter(std::string("FileId"), fileId);
+}
+

ecd/src/model/ListFilePermissionResult.cc

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/ListFilePermissionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+ListFilePermissionResult::ListFilePermissionResult() :
+	ServiceResult()
+{}
+
+ListFilePermissionResult::ListFilePermissionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListFilePermissionResult::~ListFilePermissionResult()
+{}
+
+void ListFilePermissionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFilePermissionsNode = value["FilePermissions"]["filePermission"];
+	for (auto valueFilePermissionsfilePermission : allFilePermissionsNode)
+	{
+		FilePermission filePermissionsObject;
+		if(!valueFilePermissionsfilePermission["RoleId"].isNull())
+			filePermissionsObject.roleId = valueFilePermissionsfilePermission["RoleId"].asString();
+		if(!valueFilePermissionsfilePermission["ExpireTime"].isNull())
+			filePermissionsObject.expireTime = std::stol(valueFilePermissionsfilePermission["ExpireTime"].asString());
+		if(!valueFilePermissionsfilePermission["DisinheritSubGroup"].isNull())
+			filePermissionsObject.disinheritSubGroup = valueFilePermissionsfilePermission["DisinheritSubGroup"].asString() == "true";
+		auto cdsIdentityNode = value["CdsIdentity"];
+		if(!cdsIdentityNode["Id"].isNull())
+			filePermissionsObject.cdsIdentity.id = cdsIdentityNode["Id"].asString();
+		if(!cdsIdentityNode["Type"].isNull())
+			filePermissionsObject.cdsIdentity.type = cdsIdentityNode["Type"].asString();
+		filePermissions_.push_back(filePermissionsObject);
+	}
+
+}
+
+std::vector<ListFilePermissionResult::FilePermission> ListFilePermissionResult::getFilePermissions()const
+{
+	return filePermissions_;
+}
+

ecd/src/model/ListUserAdOrganizationUnitsRequest.cc

@@ -34,6 +34,15 @@ void ListUserAdOrganizationUnitsRequest::setOfficeSiteId(const std::string &offi
   setParameter(std::string("OfficeSiteId"), officeSiteId);
 }
 
+std::string ListUserAdOrganizationUnitsRequest::getFilter() const {
+  return filter_;
+}
+
+void ListUserAdOrganizationUnitsRequest::setFilter(const std::string &filter) {
+  filter_ = filter;
+  setParameter(std::string("Filter"), filter);
+}
+
 std::string ListUserAdOrganizationUnitsRequest::getRegionId() const {
   return regionId_;
 }
@@ -43,3 +52,21 @@ void ListUserAdOrganizationUnitsRequest::setRegionId(const std::string &regionId
   setParameter(std::string("RegionId"), regionId);
 }
 
+std::string ListUserAdOrganizationUnitsRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListUserAdOrganizationUnitsRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+int ListUserAdOrganizationUnitsRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListUserAdOrganizationUnitsRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

ecd/src/model/ListUserAdOrganizationUnitsResult.cc

@@ -47,8 +47,12 @@ void ListUserAdOrganizationUnitsResult::parse(const std::string &payload)
 			oUNamesObject.officeSiteId = valueOUNamesouName["OfficeSiteId"].asString();
 		if(!valueOUNamesouName["OUName"].isNull())
 			oUNamesObject.oUName = valueOUNamesouName["OUName"].asString();
+		if(!valueOUNamesouName["DisplayOUName"].isNull())
+			oUNamesObject.displayOUName = valueOUNamesouName["DisplayOUName"].asString();
 		oUNames_.push_back(oUNamesObject);
 	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
 
 }
 
@@ -57,3 +61,8 @@ std::vector<ListUserAdOrganizationUnitsResult::OuName> ListUserAdOrganizationUni
 	return oUNames_;
 }
 
+std::string ListUserAdOrganizationUnitsResult::getNextToken()const
+{
+	return nextToken_;
+}
+

ecd/src/model/MigrateDesktopsRequest.cc

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/MigrateDesktopsRequest.h>
+
+using AlibabaCloud::Ecd::Model::MigrateDesktopsRequest;
+
+MigrateDesktopsRequest::MigrateDesktopsRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "MigrateDesktops") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+MigrateDesktopsRequest::~MigrateDesktopsRequest() {}
+
+std::string MigrateDesktopsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void MigrateDesktopsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> MigrateDesktopsRequest::getDesktopId() const {
+  return desktopId_;
+}
+
+void MigrateDesktopsRequest::setDesktopId(const std::vector<std::string> &desktopId) {
+  desktopId_ = desktopId;
+}
+
+std::string MigrateDesktopsRequest::getTargetOfficeSiteId() const {
+  return targetOfficeSiteId_;
+}
+
+void MigrateDesktopsRequest::setTargetOfficeSiteId(const std::string &targetOfficeSiteId) {
+  targetOfficeSiteId_ = targetOfficeSiteId;
+  setParameter(std::string("TargetOfficeSiteId"), targetOfficeSiteId);
+}
+

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

ecd/src/model/ModifyAutoSnapshotPolicyRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/ModifyAutoSnapshotPolicyRequest.h>
+
+using AlibabaCloud::Ecd::Model::ModifyAutoSnapshotPolicyRequest;
+
+ModifyAutoSnapshotPolicyRequest::ModifyAutoSnapshotPolicyRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ModifyAutoSnapshotPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ModifyAutoSnapshotPolicyRequest::~ModifyAutoSnapshotPolicyRequest() {}
+
+std::string ModifyAutoSnapshotPolicyRequest::getCronExpression() const {
+  return cronExpression_;
+}
+
+void ModifyAutoSnapshotPolicyRequest::setCronExpression(const std::string &cronExpression) {
+  cronExpression_ = cronExpression;
+  setParameter(std::string("CronExpression"), cronExpression);
+}
+
+std::string ModifyAutoSnapshotPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void ModifyAutoSnapshotPolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string ModifyAutoSnapshotPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ModifyAutoSnapshotPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ModifyAutoSnapshotPolicyRequest::getPolicyName() const {
+  return policyName_;
+}
+
+void ModifyAutoSnapshotPolicyRequest::setPolicyName(const std::string &policyName) {
+  policyName_ = policyName;
+  setParameter(std::string("PolicyName"), policyName);
+}
+
+int ModifyAutoSnapshotPolicyRequest::getRetentionDays() const {
+  return retentionDays_;
+}
+
+void ModifyAutoSnapshotPolicyRequest::setRetentionDays(int retentionDays) {
+  retentionDays_ = retentionDays;
+  setParameter(std::string("RetentionDays"), std::to_string(retentionDays));
+}
+

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

ecd/src/model/ModifyCdsFileRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/ecd/model/ModifyCdsFileRequest.h>
+
+using AlibabaCloud::Ecd::Model::ModifyCdsFileRequest;
+
+ModifyCdsFileRequest::ModifyCdsFileRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ModifyCdsFile") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ModifyCdsFileRequest::~ModifyCdsFileRequest() {}
+
+std::string ModifyCdsFileRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void ModifyCdsFileRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string ModifyCdsFileRequest::getConflictPolicy() const {
+  return conflictPolicy_;
+}
+
+void ModifyCdsFileRequest::setConflictPolicy(const std::string &conflictPolicy) {
+  conflictPolicy_ = conflictPolicy;
+  setParameter(std::string("ConflictPolicy"), conflictPolicy);
+}
+
+std::string ModifyCdsFileRequest::getFileName() const {
+  return fileName_;
+}
+
+void ModifyCdsFileRequest::setFileName(const std::string &fileName) {
+  fileName_ = fileName;
+  setParameter(std::string("FileName"), fileName);
+}
+
+std::string ModifyCdsFileRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ModifyCdsFileRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ModifyCdsFileRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void ModifyCdsFileRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string ModifyCdsFileRequest::getFileId() const {
+  return fileId_;
+}
+
+void ModifyCdsFileRequest::setFileId(const std::string &fileId) {
+  fileId_ = fileId;
+  setParameter(std::string("FileId"), fileId);
+}
+

ecd/src/model/ModifyCdsFileResult.cc

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

ecd/src/model/ModifyCdsFileShareLinkRequest.cc

@@ -0,0 +1,189 @@
+/*
+ * 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/ecd/model/ModifyCdsFileShareLinkRequest.h>
+
+using AlibabaCloud::Ecd::Model::ModifyCdsFileShareLinkRequest;
+
+ModifyCdsFileShareLinkRequest::ModifyCdsFileShareLinkRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ModifyCdsFileShareLink") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ModifyCdsFileShareLinkRequest::~ModifyCdsFileShareLinkRequest() {}
+
+std::string ModifyCdsFileShareLinkRequest::getDescription() const {
+  return description_;
+}
+
+void ModifyCdsFileShareLinkRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string ModifyCdsFileShareLinkRequest::getShareId() const {
+  return shareId_;
+}
+
+void ModifyCdsFileShareLinkRequest::setShareId(const std::string &shareId) {
+  shareId_ = shareId;
+  setParameter(std::string("ShareId"), shareId);
+}
+
+long ModifyCdsFileShareLinkRequest::getPreviewLimit() const {
+  return previewLimit_;
+}
+
+void ModifyCdsFileShareLinkRequest::setPreviewLimit(long previewLimit) {
+  previewLimit_ = previewLimit;
+  setParameter(std::string("PreviewLimit"), std::to_string(previewLimit));
+}
+
+bool ModifyCdsFileShareLinkRequest::getDisableDownload() const {
+  return disableDownload_;
+}
+
+void ModifyCdsFileShareLinkRequest::setDisableDownload(bool disableDownload) {
+  disableDownload_ = disableDownload;
+  setParameter(std::string("DisableDownload"), disableDownload ? "true" : "false");
+}
+
+bool ModifyCdsFileShareLinkRequest::getDisablePreview() const {
+  return disablePreview_;
+}
+
+void ModifyCdsFileShareLinkRequest::setDisablePreview(bool disablePreview) {
+  disablePreview_ = disablePreview;
+  setParameter(std::string("DisablePreview"), disablePreview ? "true" : "false");
+}
+
+std::string ModifyCdsFileShareLinkRequest::getSharePwd() const {
+  return sharePwd_;
+}
+
+void ModifyCdsFileShareLinkRequest::setSharePwd(const std::string &sharePwd) {
+  sharePwd_ = sharePwd;
+  setParameter(std::string("SharePwd"), sharePwd);
+}
+
+std::string ModifyCdsFileShareLinkRequest::getShareName() const {
+  return shareName_;
+}
+
+void ModifyCdsFileShareLinkRequest::setShareName(const std::string &shareName) {
+  shareName_ = shareName;
+  setParameter(std::string("ShareName"), shareName);
+}
+
+long ModifyCdsFileShareLinkRequest::getDownloadCount() const {
+  return downloadCount_;
+}
+
+void ModifyCdsFileShareLinkRequest::setDownloadCount(long downloadCount) {
+  downloadCount_ = downloadCount;
+  setParameter(std::string("DownloadCount"), std::to_string(downloadCount));
+}
+
+bool ModifyCdsFileShareLinkRequest::getDisableSave() const {
+  return disableSave_;
+}
+
+void ModifyCdsFileShareLinkRequest::setDisableSave(bool disableSave) {
+  disableSave_ = disableSave;
+  setParameter(std::string("DisableSave"), disableSave ? "true" : "false");
+}
+
+long ModifyCdsFileShareLinkRequest::getSaveCount() const {
+  return saveCount_;
+}
+
+void ModifyCdsFileShareLinkRequest::setSaveCount(long saveCount) {
+  saveCount_ = saveCount;
+  setParameter(std::string("SaveCount"), std::to_string(saveCount));
+}
+
+long ModifyCdsFileShareLinkRequest::getReportCount() const {
+  return reportCount_;
+}
+
+void ModifyCdsFileShareLinkRequest::setReportCount(long reportCount) {
+  reportCount_ = reportCount;
+  setParameter(std::string("ReportCount"), std::to_string(reportCount));
+}
+
+long ModifyCdsFileShareLinkRequest::getVideoPreviewCount() const {
+  return videoPreviewCount_;
+}
+
+void ModifyCdsFileShareLinkRequest::setVideoPreviewCount(long videoPreviewCount) {
+  videoPreviewCount_ = videoPreviewCount;
+  setParameter(std::string("VideoPreviewCount"), std::to_string(videoPreviewCount));
+}
+
+long ModifyCdsFileShareLinkRequest::getDownloadLimit() const {
+  return downloadLimit_;
+}
+
+void ModifyCdsFileShareLinkRequest::setDownloadLimit(long downloadLimit) {
+  downloadLimit_ = downloadLimit;
+  setParameter(std::string("DownloadLimit"), std::to_string(downloadLimit));
+}
+
+std::string ModifyCdsFileShareLinkRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void ModifyCdsFileShareLinkRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+long ModifyCdsFileShareLinkRequest::getSaveLimit() const {
+  return saveLimit_;
+}
+
+void ModifyCdsFileShareLinkRequest::setSaveLimit(long saveLimit) {
+  saveLimit_ = saveLimit;
+  setParameter(std::string("SaveLimit"), std::to_string(saveLimit));
+}
+
+std::string ModifyCdsFileShareLinkRequest::getExpiration() const {
+  return expiration_;
+}
+
+void ModifyCdsFileShareLinkRequest::setExpiration(const std::string &expiration) {
+  expiration_ = expiration;
+  setParameter(std::string("Expiration"), expiration);
+}
+
+long ModifyCdsFileShareLinkRequest::getPreviewCount() const {
+  return previewCount_;
+}
+
+void ModifyCdsFileShareLinkRequest::setPreviewCount(long previewCount) {
+  previewCount_ = previewCount;
+  setParameter(std::string("PreviewCount"), std::to_string(previewCount));
+}
+
+std::string ModifyCdsFileShareLinkRequest::getStatus() const {
+  return status_;
+}
+
+void ModifyCdsFileShareLinkRequest::setStatus(const std::string &status) {
+  status_ = status;
+  setParameter(std::string("Status"), status);
+}
+

ecd/src/model/ModifyCdsFileShareLinkResult.cc

@@ -0,0 +1,121 @@
+/*
+ * 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/ecd/model/ModifyCdsFileShareLinkResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+ModifyCdsFileShareLinkResult::ModifyCdsFileShareLinkResult() :
+	ServiceResult()
+{}
+
+ModifyCdsFileShareLinkResult::ModifyCdsFileShareLinkResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyCdsFileShareLinkResult::~ModifyCdsFileShareLinkResult()
+{}
+
+void ModifyCdsFileShareLinkResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Description"].isNull())
+		data_.description = dataNode["Description"].asString();
+	if(!dataNode["SaveLimit"].isNull())
+		data_.saveLimit = std::stol(dataNode["SaveLimit"].asString());
+	if(!dataNode["DownloadCount"].isNull())
+		data_.downloadCount = std::stol(dataNode["DownloadCount"].asString());
+	if(!dataNode["Creator"].isNull())
+		data_.creator = dataNode["Creator"].asString();
+	if(!dataNode["SaveCount"].isNull())
+		data_.saveCount = std::stol(dataNode["SaveCount"].asString());
+	if(!dataNode["DisableSave"].isNull())
+		data_.disableSave = dataNode["DisableSave"].asString() == "true";
+	if(!dataNode["SharePwd"].isNull())
+		data_.sharePwd = dataNode["SharePwd"].asString();
+	if(!dataNode["DisablePreview"].isNull())
+		data_.disablePreview = dataNode["DisablePreview"].asString() == "true";
+	if(!dataNode["AccessCount"].isNull())
+		data_.accessCount = std::stol(dataNode["AccessCount"].asString());
+	if(!dataNode["ShareId"].isNull())
+		data_.shareId = dataNode["ShareId"].asString();
+	if(!dataNode["DownloadLimit"].isNull())
+		data_.downloadLimit = std::stol(dataNode["DownloadLimit"].asString());
+	if(!dataNode["Status"].isNull())
+		data_.status = dataNode["Status"].asString();
+	if(!dataNode["DriveId"].isNull())
+		data_.driveId = dataNode["DriveId"].asString();
+	if(!dataNode["ModifiyTime"].isNull())
+		data_.modifiyTime = dataNode["ModifiyTime"].asString();
+	if(!dataNode["DisableDownload"].isNull())
+		data_.disableDownload = dataNode["DisableDownload"].asString() == "true";
+	if(!dataNode["Expiration"].isNull())
+		data_.expiration = dataNode["Expiration"].asString();
+	if(!dataNode["Expired"].isNull())
+		data_.expired = dataNode["Expired"].asString() == "true";
+	if(!dataNode["PreviewCount"].isNull())
+		data_.previewCount = std::stol(dataNode["PreviewCount"].asString());
+	if(!dataNode["PreviewLimit"].isNull())
+		data_.previewLimit = std::stol(dataNode["PreviewLimit"].asString());
+	if(!dataNode["VideoPreviewCount"].isNull())
+		data_.videoPreviewCount = std::stol(dataNode["VideoPreviewCount"].asString());
+	if(!dataNode["ReportCount"].isNull())
+		data_.reportCount = std::stol(dataNode["ReportCount"].asString());
+	if(!dataNode["FileIds"].isNull())
+		data_.fileIds = dataNode["FileIds"].asString();
+	if(!dataNode["ShareName"].isNull())
+		data_.shareName = dataNode["ShareName"].asString();
+	if(!dataNode["CreateTime"].isNull())
+		data_.createTime = dataNode["CreateTime"].asString();
+	if(!dataNode["ShareLink"].isNull())
+		data_.shareLink = dataNode["ShareLink"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string ModifyCdsFileShareLinkResult::getMessage()const
+{
+	return message_;
+}
+
+ModifyCdsFileShareLinkResult::Data ModifyCdsFileShareLinkResult::getData()const
+{
+	return data_;
+}
+
+std::string ModifyCdsFileShareLinkResult::getCode()const
+{
+	return code_;
+}
+
+bool ModifyCdsFileShareLinkResult::getSuccess()const
+{
+	return success_;
+}
+

ecd/src/model/ModifyCloudDriveGroupsRequest.cc

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/ModifyCloudDriveGroupsRequest.h>
+
+using AlibabaCloud::Ecd::Model::ModifyCloudDriveGroupsRequest;
+
+ModifyCloudDriveGroupsRequest::ModifyCloudDriveGroupsRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ModifyCloudDriveGroups") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ModifyCloudDriveGroupsRequest::~ModifyCloudDriveGroupsRequest() {}
+
+long ModifyCloudDriveGroupsRequest::getTotalSize() const {
+  return totalSize_;
+}
+
+void ModifyCloudDriveGroupsRequest::setTotalSize(long totalSize) {
+  totalSize_ = totalSize;
+  setParameter(std::string("TotalSize"), std::to_string(totalSize));
+}
+
+std::vector<std::string> ModifyCloudDriveGroupsRequest::getGroupId() const {
+  return groupId_;
+}
+
+void ModifyCloudDriveGroupsRequest::setGroupId(const std::vector<std::string> &groupId) {
+  groupId_ = groupId;
+}
+
+std::string ModifyCloudDriveGroupsRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void ModifyCloudDriveGroupsRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string ModifyCloudDriveGroupsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ModifyCloudDriveGroupsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ModifyCloudDriveGroupsRequest::getStatus() const {
+  return status_;
+}
+
+void ModifyCloudDriveGroupsRequest::setStatus(const std::string &status) {
+  status_ = status;
+  setParameter(std::string("Status"), status);
+}
+

ecd/src/model/ModifyCloudDriveGroupsResult.cc

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

ecd/src/model/ModifyDesktopGroupRequest.cc

@@ -97,6 +97,14 @@ void ModifyDesktopGroupRequest::setAllowBufferCount(int allowBufferCount) {
   setParameter(std::string("AllowBufferCount"), std::to_string(allowBufferCount));
 }
 
+std::vector<std::string> ModifyDesktopGroupRequest::getPolicyGroupIds() const {
+  return policyGroupIds_;
+}
+
+void ModifyDesktopGroupRequest::setPolicyGroupIds(const std::vector<std::string> &policyGroupIds) {
+  policyGroupIds_ = policyGroupIds;
+}
+
 long ModifyDesktopGroupRequest::getIdleDisconnectDuration() const {
   return idleDisconnectDuration_;
 }
@@ -232,6 +240,15 @@ void ModifyDesktopGroupRequest::setProfileFollowSwitch(bool profileFollowSwitch)
   setParameter(std::string("ProfileFollowSwitch"), profileFollowSwitch ? "true" : "false");
 }
 
+int ModifyDesktopGroupRequest::getBuyDesktopsCount() const {
+  return buyDesktopsCount_;
+}
+
+void ModifyDesktopGroupRequest::setBuyDesktopsCount(int buyDesktopsCount) {
+  buyDesktopsCount_ = buyDesktopsCount;
+  setParameter(std::string("BuyDesktopsCount"), std::to_string(buyDesktopsCount));
+}
+
 std::string ModifyDesktopGroupRequest::getPolicyGroupId() const {
   return policyGroupId_;
 }

ecd/src/model/ModifyDesktopsPolicyGroupRequest.cc

@@ -25,6 +25,23 @@ ModifyDesktopsPolicyGroupRequest::ModifyDesktopsPolicyGroupRequest()
 
 ModifyDesktopsPolicyGroupRequest::~ModifyDesktopsPolicyGroupRequest() {}
 
+bool ModifyDesktopsPolicyGroupRequest::getPreCheck() const {
+  return preCheck_;
+}
+
+void ModifyDesktopsPolicyGroupRequest::setPreCheck(bool preCheck) {
+  preCheck_ = preCheck;
+  setParameter(std::string("PreCheck"), preCheck ? "true" : "false");
+}
+
+std::vector<std::string> ModifyDesktopsPolicyGroupRequest::getPolicyGroupIds() const {
+  return policyGroupIds_;
+}
+
+void ModifyDesktopsPolicyGroupRequest::setPolicyGroupIds(const std::vector<std::string> &policyGroupIds) {
+  policyGroupIds_ = policyGroupIds;
+}
+
 std::string ModifyDesktopsPolicyGroupRequest::getRegionId() const {
   return regionId_;
 }

ecd/src/model/ModifyDesktopsPolicyGroupResult.cc

@@ -49,6 +49,8 @@ void ModifyDesktopsPolicyGroupResult::parse(const std::string &payload)
 			modifyResultsObject.message = valueModifyResultsModifyResult["Message"].asString();
 		if(!valueModifyResultsModifyResult["DesktopId"].isNull())
 			modifyResultsObject.desktopId = valueModifyResultsModifyResult["DesktopId"].asString();
+		if(!valueModifyResultsModifyResult["CheckResult"].isNull())
+			modifyResultsObject.checkResult = valueModifyResultsModifyResult["CheckResult"].asString() == "true";
 		modifyResults_.push_back(modifyResultsObject);
 	}