Support remote coordinate control.

ecd/src/model/ActivateOfficeSiteRequest.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/ActivateOfficeSiteRequest.h>
+
+using AlibabaCloud::Ecd::Model::ActivateOfficeSiteRequest;
+
+ActivateOfficeSiteRequest::ActivateOfficeSiteRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ActivateOfficeSite") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ActivateOfficeSiteRequest::~ActivateOfficeSiteRequest() {}
+
+std::string ActivateOfficeSiteRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void ActivateOfficeSiteRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::string ActivateOfficeSiteRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ActivateOfficeSiteRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ecd/src/model/AddUserToDesktopGroupRequest.cc

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/AddUserToDesktopGroupRequest.h>
+
+using AlibabaCloud::Ecd::Model::AddUserToDesktopGroupRequest;
+
+AddUserToDesktopGroupRequest::AddUserToDesktopGroupRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "AddUserToDesktopGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddUserToDesktopGroupRequest::~AddUserToDesktopGroupRequest() {}
+
+std::vector<std::string> AddUserToDesktopGroupRequest::getEndUserIds() const {
+  return endUserIds_;
+}
+
+void AddUserToDesktopGroupRequest::setEndUserIds(const std::vector<std::string> &endUserIds) {
+  endUserIds_ = endUserIds;
+}
+
+std::string AddUserToDesktopGroupRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AddUserToDesktopGroupRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AddUserToDesktopGroupRequest::getDesktopGroupId() const {
+  return desktopGroupId_;
+}
+
+void AddUserToDesktopGroupRequest::setDesktopGroupId(const std::string &desktopGroupId) {
+  desktopGroupId_ = desktopGroupId;
+  setParameter(std::string("DesktopGroupId"), desktopGroupId);
+}
+
+std::string AddUserToDesktopGroupRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AddUserToDesktopGroupRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> AddUserToDesktopGroupRequest::getDesktopGroupIds() const {
+  return desktopGroupIds_;
+}
+
+void AddUserToDesktopGroupRequest::setDesktopGroupIds(const std::vector<std::string> &desktopGroupIds) {
+  desktopGroupIds_ = desktopGroupIds;
+}
+

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

ecd/src/model/ApplyCoordinatePrivilegeRequest.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/ApplyCoordinatePrivilegeRequest.h>
+
+using AlibabaCloud::Ecd::Model::ApplyCoordinatePrivilegeRequest;
+
+ApplyCoordinatePrivilegeRequest::ApplyCoordinatePrivilegeRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ApplyCoordinatePrivilege") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ApplyCoordinatePrivilegeRequest::~ApplyCoordinatePrivilegeRequest() {}
+
+std::string ApplyCoordinatePrivilegeRequest::getCoId() const {
+  return coId_;
+}
+
+void ApplyCoordinatePrivilegeRequest::setCoId(const std::string &coId) {
+  coId_ = coId;
+  setParameter(std::string("CoId"), coId);
+}
+
+std::string ApplyCoordinatePrivilegeRequest::getUserType() const {
+  return userType_;
+}
+
+void ApplyCoordinatePrivilegeRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+std::string ApplyCoordinatePrivilegeRequest::getUuid() const {
+  return uuid_;
+}
+
+void ApplyCoordinatePrivilegeRequest::setUuid(const std::string &uuid) {
+  uuid_ = uuid;
+  setParameter(std::string("Uuid"), uuid);
+}
+
+std::string ApplyCoordinatePrivilegeRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ApplyCoordinatePrivilegeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ApplyCoordinatePrivilegeRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void ApplyCoordinatePrivilegeRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+

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

ecd/src/model/ApplyCoordinationForMonitoringRequest.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/ApplyCoordinationForMonitoringRequest.h>
+
+using AlibabaCloud::Ecd::Model::ApplyCoordinationForMonitoringRequest;
+
+ApplyCoordinationForMonitoringRequest::ApplyCoordinationForMonitoringRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ApplyCoordinationForMonitoring") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ApplyCoordinationForMonitoringRequest::~ApplyCoordinationForMonitoringRequest() {}
+
+std::string ApplyCoordinationForMonitoringRequest::getUuid() const {
+  return uuid_;
+}
+
+void ApplyCoordinationForMonitoringRequest::setUuid(const std::string &uuid) {
+  uuid_ = uuid;
+  setParameter(std::string("Uuid"), uuid);
+}
+
+std::string ApplyCoordinationForMonitoringRequest::getInitiatorType() const {
+  return initiatorType_;
+}
+
+void ApplyCoordinationForMonitoringRequest::setInitiatorType(const std::string &initiatorType) {
+  initiatorType_ = initiatorType;
+  setParameter(std::string("InitiatorType"), initiatorType);
+}
+
+std::string ApplyCoordinationForMonitoringRequest::getCoordinatePolicyType() const {
+  return coordinatePolicyType_;
+}
+
+void ApplyCoordinationForMonitoringRequest::setCoordinatePolicyType(const std::string &coordinatePolicyType) {
+  coordinatePolicyType_ = coordinatePolicyType;
+  setParameter(std::string("CoordinatePolicyType"), coordinatePolicyType);
+}
+
+std::string ApplyCoordinationForMonitoringRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ApplyCoordinationForMonitoringRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<ApplyCoordinationForMonitoringRequest::ResourceCandidates> ApplyCoordinationForMonitoringRequest::getResourceCandidates() const {
+  return resourceCandidates_;
+}
+
+void ApplyCoordinationForMonitoringRequest::setResourceCandidates(const std::vector<ApplyCoordinationForMonitoringRequest::ResourceCandidates> &resourceCandidates) {
+  resourceCandidates_ = resourceCandidates;
+  for(int dep1 = 0; dep1 != resourceCandidates.size(); dep1++) {
+  auto resourceCandidatesObj = resourceCandidates.at(dep1);
+  std::string resourceCandidatesObjStr = std::string("ResourceCandidates") + "." + std::to_string(dep1 + 1);
+    setParameter(resourceCandidatesObjStr + ".ResourceId", resourceCandidatesObj.resourceId);
+    setParameter(resourceCandidatesObjStr + ".ResourceProperties", resourceCandidatesObj.resourceProperties);
+    setParameter(resourceCandidatesObjStr + ".ResourceName", resourceCandidatesObj.resourceName);
+    setParameter(resourceCandidatesObjStr + ".ResourceType", resourceCandidatesObj.resourceType);
+    setParameter(resourceCandidatesObjStr + ".OwnerWyId", resourceCandidatesObj.ownerWyId);
+    setParameter(resourceCandidatesObjStr + ".ResourceRegionId", resourceCandidatesObj.resourceRegionId);
+    setParameter(resourceCandidatesObjStr + ".OwnerAliUid", std::to_string(resourceCandidatesObj.ownerAliUid));
+    setParameter(resourceCandidatesObjStr + ".OwnerEndUserId", resourceCandidatesObj.ownerEndUserId);
+  }
+}
+
+std::string ApplyCoordinationForMonitoringRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void ApplyCoordinationForMonitoringRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+

ecd/src/model/ApplyCoordinationForMonitoringResult.cc

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/ApplyCoordinationForMonitoringResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+ApplyCoordinationForMonitoringResult::ApplyCoordinationForMonitoringResult() :
+	ServiceResult()
+{}
+
+ApplyCoordinationForMonitoringResult::ApplyCoordinationForMonitoringResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ApplyCoordinationForMonitoringResult::~ApplyCoordinationForMonitoringResult()
+{}
+
+void ApplyCoordinationForMonitoringResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCoordinateFlowModelsNode = value["CoordinateFlowModels"]["CoordinateFlowModel"];
+	for (auto valueCoordinateFlowModelsCoordinateFlowModel : allCoordinateFlowModelsNode)
+	{
+		CoordinateFlowModel coordinateFlowModelsObject;
+		if(!valueCoordinateFlowModelsCoordinateFlowModel["CoordinateStatus"].isNull())
+			coordinateFlowModelsObject.coordinateStatus = valueCoordinateFlowModelsCoordinateFlowModel["CoordinateStatus"].asString();
+		if(!valueCoordinateFlowModelsCoordinateFlowModel["InitiatorType"].isNull())
+			coordinateFlowModelsObject.initiatorType = valueCoordinateFlowModelsCoordinateFlowModel["InitiatorType"].asString();
+		if(!valueCoordinateFlowModelsCoordinateFlowModel["OwnerUserId"].isNull())
+			coordinateFlowModelsObject.ownerUserId = valueCoordinateFlowModelsCoordinateFlowModel["OwnerUserId"].asString();
+		if(!valueCoordinateFlowModelsCoordinateFlowModel["CoordinateTicket"].isNull())
+			coordinateFlowModelsObject.coordinateTicket = valueCoordinateFlowModelsCoordinateFlowModel["CoordinateTicket"].asString();
+		if(!valueCoordinateFlowModelsCoordinateFlowModel["CoId"].isNull())
+			coordinateFlowModelsObject.coId = valueCoordinateFlowModelsCoordinateFlowModel["CoId"].asString();
+		if(!valueCoordinateFlowModelsCoordinateFlowModel["ResourceId"].isNull())
+			coordinateFlowModelsObject.resourceId = valueCoordinateFlowModelsCoordinateFlowModel["ResourceId"].asString();
+		if(!valueCoordinateFlowModelsCoordinateFlowModel["ResourceName"].isNull())
+			coordinateFlowModelsObject.resourceName = valueCoordinateFlowModelsCoordinateFlowModel["ResourceName"].asString();
+		coordinateFlowModels_.push_back(coordinateFlowModelsObject);
+	}
+
+}
+
+std::vector<ApplyCoordinationForMonitoringResult::CoordinateFlowModel> ApplyCoordinationForMonitoringResult::getCoordinateFlowModels()const
+{
+	return coordinateFlowModels_;
+}
+

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

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

ecd/src/model/AssociateNetworkPackageRequest.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/AssociateNetworkPackageRequest.h>
+
+using AlibabaCloud::Ecd::Model::AssociateNetworkPackageRequest;
+
+AssociateNetworkPackageRequest::AssociateNetworkPackageRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "AssociateNetworkPackage") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AssociateNetworkPackageRequest::~AssociateNetworkPackageRequest() {}
+
+std::string AssociateNetworkPackageRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void AssociateNetworkPackageRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::string AssociateNetworkPackageRequest::getNetworkPackageId() const {
+  return networkPackageId_;
+}
+
+void AssociateNetworkPackageRequest::setNetworkPackageId(const std::string &networkPackageId) {
+  networkPackageId_ = networkPackageId;
+  setParameter(std::string("NetworkPackageId"), networkPackageId);
+}
+
+std::string AssociateNetworkPackageRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AssociateNetworkPackageRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ecd/src/model/AttachCenRequest.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/AttachCenRequest.h>
+
+using AlibabaCloud::Ecd::Model::AttachCenRequest;
+
+AttachCenRequest::AttachCenRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "AttachCen") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AttachCenRequest::~AttachCenRequest() {}
+
+std::string AttachCenRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void AttachCenRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::string AttachCenRequest::getCenId() const {
+  return cenId_;
+}
+
+void AttachCenRequest::setCenId(const std::string &cenId) {
+  cenId_ = cenId;
+  setParameter(std::string("CenId"), cenId);
+}
+
+long AttachCenRequest::getCenOwnerId() const {
+  return cenOwnerId_;
+}
+
+void AttachCenRequest::setCenOwnerId(long cenOwnerId) {
+  cenOwnerId_ = cenOwnerId;
+  setParameter(std::string("CenOwnerId"), std::to_string(cenOwnerId));
+}
+
+std::string AttachCenRequest::getVerifyCode() const {
+  return verifyCode_;
+}
+
+void AttachCenRequest::setVerifyCode(const std::string &verifyCode) {
+  verifyCode_ = verifyCode;
+  setParameter(std::string("VerifyCode"), verifyCode);
+}
+
+std::string AttachCenRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AttachCenRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ecd/src/model/CancelCoordinationForMonitoringRequest.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/CancelCoordinationForMonitoringRequest.h>
+
+using AlibabaCloud::Ecd::Model::CancelCoordinationForMonitoringRequest;
+
+CancelCoordinationForMonitoringRequest::CancelCoordinationForMonitoringRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CancelCoordinationForMonitoring") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CancelCoordinationForMonitoringRequest::~CancelCoordinationForMonitoringRequest() {}
+
+std::string CancelCoordinationForMonitoringRequest::getUserType() const {
+  return userType_;
+}
+
+void CancelCoordinationForMonitoringRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+std::vector<std::string> CancelCoordinationForMonitoringRequest::getCoIds() const {
+  return coIds_;
+}
+
+void CancelCoordinationForMonitoringRequest::setCoIds(const std::vector<std::string> &coIds) {
+  coIds_ = coIds;
+}
+
+std::string CancelCoordinationForMonitoringRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CancelCoordinationForMonitoringRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CancelCoordinationForMonitoringRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void CancelCoordinationForMonitoringRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+

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

ecd/src/model/CancelCopyImageRequest.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/CancelCopyImageRequest.h>
+
+using AlibabaCloud::Ecd::Model::CancelCopyImageRequest;
+
+CancelCopyImageRequest::CancelCopyImageRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CancelCopyImage") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CancelCopyImageRequest::~CancelCopyImageRequest() {}
+
+std::string CancelCopyImageRequest::getImageId() const {
+  return imageId_;
+}
+
+void CancelCopyImageRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+std::string CancelCopyImageRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CancelCopyImageRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ecd/src/model/ClonePolicyGroupRequest.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/ClonePolicyGroupRequest.h>
+
+using AlibabaCloud::Ecd::Model::ClonePolicyGroupRequest;
+
+ClonePolicyGroupRequest::ClonePolicyGroupRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ClonePolicyGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ClonePolicyGroupRequest::~ClonePolicyGroupRequest() {}
+
+std::string ClonePolicyGroupRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ClonePolicyGroupRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ClonePolicyGroupRequest::getName() const {
+  return name_;
+}
+
+void ClonePolicyGroupRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string ClonePolicyGroupRequest::getPolicyGroupId() const {
+  return policyGroupId_;
+}
+
+void ClonePolicyGroupRequest::setPolicyGroupId(const std::string &policyGroupId) {
+  policyGroupId_ = policyGroupId;
+  setParameter(std::string("PolicyGroupId"), policyGroupId);
+}
+

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

ecd/src/model/ConfigADConnectorTrustRequest.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/ConfigADConnectorTrustRequest.h>
+
+using AlibabaCloud::Ecd::Model::ConfigADConnectorTrustRequest;
+
+ConfigADConnectorTrustRequest::ConfigADConnectorTrustRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ConfigADConnectorTrust") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ConfigADConnectorTrustRequest::~ConfigADConnectorTrustRequest() {}
+
+std::string ConfigADConnectorTrustRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void ConfigADConnectorTrustRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::string ConfigADConnectorTrustRequest::getTrustKey() const {
+  return trustKey_;
+}
+
+void ConfigADConnectorTrustRequest::setTrustKey(const std::string &trustKey) {
+  trustKey_ = trustKey;
+  setParameter(std::string("TrustKey"), trustKey);
+}
+
+std::string ConfigADConnectorTrustRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ConfigADConnectorTrustRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ecd/src/model/ConfigADConnectorUserRequest.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/ConfigADConnectorUserRequest.h>
+
+using AlibabaCloud::Ecd::Model::ConfigADConnectorUserRequest;
+
+ConfigADConnectorUserRequest::ConfigADConnectorUserRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "ConfigADConnectorUser") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ConfigADConnectorUserRequest::~ConfigADConnectorUserRequest() {}
+
+std::string ConfigADConnectorUserRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void ConfigADConnectorUserRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::string ConfigADConnectorUserRequest::getDomainPassword() const {
+  return domainPassword_;
+}
+
+void ConfigADConnectorUserRequest::setDomainPassword(const std::string &domainPassword) {
+  domainPassword_ = domainPassword;
+  setParameter(std::string("DomainPassword"), domainPassword);
+}
+
+std::string ConfigADConnectorUserRequest::getDomainUserName() const {
+  return domainUserName_;
+}
+
+void ConfigADConnectorUserRequest::setDomainUserName(const std::string &domainUserName) {
+  domainUserName_ = domainUserName;
+  setParameter(std::string("DomainUserName"), domainUserName);
+}
+
+std::string ConfigADConnectorUserRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ConfigADConnectorUserRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ConfigADConnectorUserRequest::getOUName() const {
+  return oUName_;
+}
+
+void ConfigADConnectorUserRequest::setOUName(const std::string &oUName) {
+  oUName_ = oUName;
+  setParameter(std::string("OUName"), oUName);
+}
+

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

ecd/src/model/CopyImageRequest.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/CopyImageRequest.h>
+
+using AlibabaCloud::Ecd::Model::CopyImageRequest;
+
+CopyImageRequest::CopyImageRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CopyImage") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CopyImageRequest::~CopyImageRequest() {}
+
+std::string CopyImageRequest::getImageId() const {
+  return imageId_;
+}
+
+void CopyImageRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+std::string CopyImageRequest::getDestinationImageName() const {
+  return destinationImageName_;
+}
+
+void CopyImageRequest::setDestinationImageName(const std::string &destinationImageName) {
+  destinationImageName_ = destinationImageName;
+  setParameter(std::string("DestinationImageName"), destinationImageName);
+}
+
+std::string CopyImageRequest::getDestinationRegionId() const {
+  return destinationRegionId_;
+}
+
+void CopyImageRequest::setDestinationRegionId(const std::string &destinationRegionId) {
+  destinationRegionId_ = destinationRegionId;
+  setParameter(std::string("DestinationRegionId"), destinationRegionId);
+}
+
+std::string CopyImageRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CopyImageRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CopyImageRequest::getDestinationDescription() const {
+  return destinationDescription_;
+}
+
+void CopyImageRequest::setDestinationDescription(const std::string &destinationDescription) {
+  destinationDescription_ = destinationDescription;
+  setParameter(std::string("DestinationDescription"), destinationDescription);
+}
+

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

ecd/src/model/CreateADConnectorDirectoryRequest.cc

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/CreateADConnectorDirectoryRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateADConnectorDirectoryRequest;
+
+CreateADConnectorDirectoryRequest::CreateADConnectorDirectoryRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateADConnectorDirectory") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateADConnectorDirectoryRequest::~CreateADConnectorDirectoryRequest() {}
+
+std::vector<std::string> CreateADConnectorDirectoryRequest::getSubDomainDnsAddress() const {
+  return subDomainDnsAddress_;
+}
+
+void CreateADConnectorDirectoryRequest::setSubDomainDnsAddress(const std::vector<std::string> &subDomainDnsAddress) {
+  subDomainDnsAddress_ = subDomainDnsAddress;
+}
+
+std::string CreateADConnectorDirectoryRequest::getSubDomainName() const {
+  return subDomainName_;
+}
+
+void CreateADConnectorDirectoryRequest::setSubDomainName(const std::string &subDomainName) {
+  subDomainName_ = subDomainName;
+  setParameter(std::string("SubDomainName"), subDomainName);
+}
+
+std::string CreateADConnectorDirectoryRequest::getDomainPassword() const {
+  return domainPassword_;
+}
+
+void CreateADConnectorDirectoryRequest::setDomainPassword(const std::string &domainPassword) {
+  domainPassword_ = domainPassword;
+  setParameter(std::string("DomainPassword"), domainPassword);
+}
+
+std::string CreateADConnectorDirectoryRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateADConnectorDirectoryRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool CreateADConnectorDirectoryRequest::getEnableAdminAccess() const {
+  return enableAdminAccess_;
+}
+
+void CreateADConnectorDirectoryRequest::setEnableAdminAccess(bool enableAdminAccess) {
+  enableAdminAccess_ = enableAdminAccess;
+  setParameter(std::string("EnableAdminAccess"), enableAdminAccess ? "true" : "false");
+}
+
+std::string CreateADConnectorDirectoryRequest::getDesktopAccessType() const {
+  return desktopAccessType_;
+}
+
+void CreateADConnectorDirectoryRequest::setDesktopAccessType(const std::string &desktopAccessType) {
+  desktopAccessType_ = desktopAccessType;
+  setParameter(std::string("DesktopAccessType"), desktopAccessType);
+}
+
+std::string CreateADConnectorDirectoryRequest::getDomainName() const {
+  return domainName_;
+}
+
+void CreateADConnectorDirectoryRequest::setDomainName(const std::string &domainName) {
+  domainName_ = domainName;
+  setParameter(std::string("DomainName"), domainName);
+}
+
+long CreateADConnectorDirectoryRequest::getSpecification() const {
+  return specification_;
+}
+
+void CreateADConnectorDirectoryRequest::setSpecification(long specification) {
+  specification_ = specification;
+  setParameter(std::string("Specification"), std::to_string(specification));
+}
+
+std::string CreateADConnectorDirectoryRequest::getDirectoryName() const {
+  return directoryName_;
+}
+
+void CreateADConnectorDirectoryRequest::setDirectoryName(const std::string &directoryName) {
+  directoryName_ = directoryName;
+  setParameter(std::string("DirectoryName"), directoryName);
+}
+
+std::vector<std::string> CreateADConnectorDirectoryRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateADConnectorDirectoryRequest::setVSwitchId(const std::vector<std::string> &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+}
+
+bool CreateADConnectorDirectoryRequest::getMfaEnabled() const {
+  return mfaEnabled_;
+}
+
+void CreateADConnectorDirectoryRequest::setMfaEnabled(bool mfaEnabled) {
+  mfaEnabled_ = mfaEnabled;
+  setParameter(std::string("MfaEnabled"), mfaEnabled ? "true" : "false");
+}
+
+std::string CreateADConnectorDirectoryRequest::getDomainUserName() const {
+  return domainUserName_;
+}
+
+void CreateADConnectorDirectoryRequest::setDomainUserName(const std::string &domainUserName) {
+  domainUserName_ = domainUserName;
+  setParameter(std::string("DomainUserName"), domainUserName);
+}
+
+std::vector<std::string> CreateADConnectorDirectoryRequest::getDnsAddress() const {
+  return dnsAddress_;
+}
+
+void CreateADConnectorDirectoryRequest::setDnsAddress(const std::vector<std::string> &dnsAddress) {
+  dnsAddress_ = dnsAddress;
+}
+

ecd/src/model/CreateADConnectorDirectoryResult.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/CreateADConnectorDirectoryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+CreateADConnectorDirectoryResult::CreateADConnectorDirectoryResult() :
+	ServiceResult()
+{}
+
+CreateADConnectorDirectoryResult::CreateADConnectorDirectoryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateADConnectorDirectoryResult::~CreateADConnectorDirectoryResult()
+{}
+
+void CreateADConnectorDirectoryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAdConnectorsNode = value["AdConnectors"]["AdConnector"];
+	for (auto valueAdConnectorsAdConnector : allAdConnectorsNode)
+	{
+		AdConnector adConnectorsObject;
+		if(!valueAdConnectorsAdConnector["Address"].isNull())
+			adConnectorsObject.address = valueAdConnectorsAdConnector["Address"].asString();
+		adConnectors_.push_back(adConnectorsObject);
+	}
+	if(!value["TrustPassword"].isNull())
+		trustPassword_ = value["TrustPassword"].asString();
+	if(!value["DirectoryId"].isNull())
+		directoryId_ = value["DirectoryId"].asString();
+
+}
+
+std::string CreateADConnectorDirectoryResult::getTrustPassword()const
+{
+	return trustPassword_;
+}
+
+std::string CreateADConnectorDirectoryResult::getDirectoryId()const
+{
+	return directoryId_;
+}
+
+std::vector<CreateADConnectorDirectoryResult::AdConnector> CreateADConnectorDirectoryResult::getAdConnectors()const
+{
+	return adConnectors_;
+}
+

ecd/src/model/CreateADConnectorOfficeSiteRequest.cc

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/CreateADConnectorOfficeSiteRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateADConnectorOfficeSiteRequest;
+
+CreateADConnectorOfficeSiteRequest::CreateADConnectorOfficeSiteRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateADConnectorOfficeSite") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateADConnectorOfficeSiteRequest::~CreateADConnectorOfficeSiteRequest() {}
+
+std::string CreateADConnectorOfficeSiteRequest::getCenId() const {
+  return cenId_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setCenId(const std::string &cenId) {
+  cenId_ = cenId;
+  setParameter(std::string("CenId"), cenId);
+}
+
+std::vector<std::string> CreateADConnectorOfficeSiteRequest::getSubDomainDnsAddress() const {
+  return subDomainDnsAddress_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setSubDomainDnsAddress(const std::vector<std::string> &subDomainDnsAddress) {
+  subDomainDnsAddress_ = subDomainDnsAddress;
+}
+
+long CreateADConnectorOfficeSiteRequest::getCenOwnerId() const {
+  return cenOwnerId_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setCenOwnerId(long cenOwnerId) {
+  cenOwnerId_ = cenOwnerId;
+  setParameter(std::string("CenOwnerId"), std::to_string(cenOwnerId));
+}
+
+bool CreateADConnectorOfficeSiteRequest::getEnableInternetAccess() const {
+  return enableInternetAccess_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setEnableInternetAccess(bool enableInternetAccess) {
+  enableInternetAccess_ = enableInternetAccess;
+  setParameter(std::string("EnableInternetAccess"), enableInternetAccess ? "true" : "false");
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getSubDomainName() const {
+  return subDomainName_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setSubDomainName(const std::string &subDomainName) {
+  subDomainName_ = subDomainName;
+  setParameter(std::string("SubDomainName"), subDomainName);
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getDomainPassword() const {
+  return domainPassword_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setDomainPassword(const std::string &domainPassword) {
+  domainPassword_ = domainPassword;
+  setParameter(std::string("DomainPassword"), domainPassword);
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getVerifyCode() const {
+  return verifyCode_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setVerifyCode(const std::string &verifyCode) {
+  verifyCode_ = verifyCode;
+  setParameter(std::string("VerifyCode"), verifyCode);
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool CreateADConnectorOfficeSiteRequest::getEnableAdminAccess() const {
+  return enableAdminAccess_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setEnableAdminAccess(bool enableAdminAccess) {
+  enableAdminAccess_ = enableAdminAccess;
+  setParameter(std::string("EnableAdminAccess"), enableAdminAccess ? "true" : "false");
+}
+
+int CreateADConnectorOfficeSiteRequest::getBandwidth() const {
+  return bandwidth_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getDesktopAccessType() const {
+  return desktopAccessType_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setDesktopAccessType(const std::string &desktopAccessType) {
+  desktopAccessType_ = desktopAccessType;
+  setParameter(std::string("DesktopAccessType"), desktopAccessType);
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getAdHostname() const {
+  return adHostname_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setAdHostname(const std::string &adHostname) {
+  adHostname_ = adHostname;
+  setParameter(std::string("AdHostname"), adHostname);
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getDomainName() const {
+  return domainName_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setDomainName(const std::string &domainName) {
+  domainName_ = domainName;
+  setParameter(std::string("DomainName"), domainName);
+}
+
+long CreateADConnectorOfficeSiteRequest::getSpecification() const {
+  return specification_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setSpecification(long specification) {
+  specification_ = specification;
+  setParameter(std::string("Specification"), std::to_string(specification));
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getOfficeSiteName() const {
+  return officeSiteName_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setOfficeSiteName(const std::string &officeSiteName) {
+  officeSiteName_ = officeSiteName;
+  setParameter(std::string("OfficeSiteName"), officeSiteName);
+}
+
+bool CreateADConnectorOfficeSiteRequest::getMfaEnabled() const {
+  return mfaEnabled_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setMfaEnabled(bool mfaEnabled) {
+  mfaEnabled_ = mfaEnabled;
+  setParameter(std::string("MfaEnabled"), mfaEnabled ? "true" : "false");
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getDomainUserName() const {
+  return domainUserName_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setDomainUserName(const std::string &domainUserName) {
+  domainUserName_ = domainUserName;
+  setParameter(std::string("DomainUserName"), domainUserName);
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getCidrBlock() const {
+  return cidrBlock_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setCidrBlock(const std::string &cidrBlock) {
+  cidrBlock_ = cidrBlock;
+  setParameter(std::string("CidrBlock"), cidrBlock);
+}
+
+std::string CreateADConnectorOfficeSiteRequest::getProtocolType() const {
+  return protocolType_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setProtocolType(const std::string &protocolType) {
+  protocolType_ = protocolType;
+  setParameter(std::string("ProtocolType"), protocolType);
+}
+
+std::vector<std::string> CreateADConnectorOfficeSiteRequest::getDnsAddress() const {
+  return dnsAddress_;
+}
+
+void CreateADConnectorOfficeSiteRequest::setDnsAddress(const std::vector<std::string> &dnsAddress) {
+  dnsAddress_ = dnsAddress;
+}
+

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

ecd/src/model/CreateAndBindNasFileSystemRequest.cc

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/CreateAndBindNasFileSystemRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateAndBindNasFileSystemRequest;
+
+CreateAndBindNasFileSystemRequest::CreateAndBindNasFileSystemRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateAndBindNasFileSystem") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateAndBindNasFileSystemRequest::~CreateAndBindNasFileSystemRequest() {}
+
+std::string CreateAndBindNasFileSystemRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void CreateAndBindNasFileSystemRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::vector<std::string> CreateAndBindNasFileSystemRequest::getEndUserIds() const {
+  return endUserIds_;
+}
+
+void CreateAndBindNasFileSystemRequest::setEndUserIds(const std::vector<std::string> &endUserIds) {
+  endUserIds_ = endUserIds;
+}
+
+std::string CreateAndBindNasFileSystemRequest::getDescription() const {
+  return description_;
+}
+
+void CreateAndBindNasFileSystemRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreateAndBindNasFileSystemRequest::getStorageType() const {
+  return storageType_;
+}
+
+void CreateAndBindNasFileSystemRequest::setStorageType(const std::string &storageType) {
+  storageType_ = storageType;
+  setParameter(std::string("StorageType"), storageType);
+}
+
+int CreateAndBindNasFileSystemRequest::getEncryptType() const {
+  return encryptType_;
+}
+
+void CreateAndBindNasFileSystemRequest::setEncryptType(int encryptType) {
+  encryptType_ = encryptType;
+  setParameter(std::string("EncryptType"), std::to_string(encryptType));
+}
+
+std::string CreateAndBindNasFileSystemRequest::getDesktopGroupId() const {
+  return desktopGroupId_;
+}
+
+void CreateAndBindNasFileSystemRequest::setDesktopGroupId(const std::string &desktopGroupId) {
+  desktopGroupId_ = desktopGroupId;
+  setParameter(std::string("DesktopGroupId"), desktopGroupId);
+}
+
+std::string CreateAndBindNasFileSystemRequest::getFileSystemName() const {
+  return fileSystemName_;
+}
+
+void CreateAndBindNasFileSystemRequest::setFileSystemName(const std::string &fileSystemName) {
+  fileSystemName_ = fileSystemName;
+  setParameter(std::string("FileSystemName"), fileSystemName);
+}
+
+std::string CreateAndBindNasFileSystemRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateAndBindNasFileSystemRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ecd/src/model/CreateBundleRequest.cc

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/CreateBundleRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateBundleRequest;
+
+CreateBundleRequest::CreateBundleRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateBundle") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateBundleRequest::~CreateBundleRequest() {}
+
+std::string CreateBundleRequest::getRootDiskPerformanceLevel() const {
+  return rootDiskPerformanceLevel_;
+}
+
+void CreateBundleRequest::setRootDiskPerformanceLevel(const std::string &rootDiskPerformanceLevel) {
+  rootDiskPerformanceLevel_ = rootDiskPerformanceLevel;
+  setParameter(std::string("RootDiskPerformanceLevel"), rootDiskPerformanceLevel);
+}
+
+std::string CreateBundleRequest::getImageId() const {
+  return imageId_;
+}
+
+void CreateBundleRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+std::string CreateBundleRequest::getDescription() const {
+  return description_;
+}
+
+void CreateBundleRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreateBundleRequest::getLanguage() const {
+  return language_;
+}
+
+void CreateBundleRequest::setLanguage(const std::string &language) {
+  language_ = language;
+  setParameter(std::string("Language"), language);
+}
+
+std::string CreateBundleRequest::getUserDiskPerformanceLevel() const {
+  return userDiskPerformanceLevel_;
+}
+
+void CreateBundleRequest::setUserDiskPerformanceLevel(const std::string &userDiskPerformanceLevel) {
+  userDiskPerformanceLevel_ = userDiskPerformanceLevel;
+  setParameter(std::string("UserDiskPerformanceLevel"), userDiskPerformanceLevel);
+}
+
+std::string CreateBundleRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateBundleRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateBundleRequest::getDesktopType() const {
+  return desktopType_;
+}
+
+void CreateBundleRequest::setDesktopType(const std::string &desktopType) {
+  desktopType_ = desktopType;
+  setParameter(std::string("DesktopType"), desktopType);
+}
+
+std::string CreateBundleRequest::getBundleName() const {
+  return bundleName_;
+}
+
+void CreateBundleRequest::setBundleName(const std::string &bundleName) {
+  bundleName_ = bundleName;
+  setParameter(std::string("BundleName"), bundleName);
+}
+
+std::vector<int> CreateBundleRequest::getUserDiskSizeGib() const {
+  return userDiskSizeGib_;
+}
+
+void CreateBundleRequest::setUserDiskSizeGib(const std::vector<int> &userDiskSizeGib) {
+  userDiskSizeGib_ = userDiskSizeGib;
+}
+
+int CreateBundleRequest::getRootDiskSizeGib() const {
+  return rootDiskSizeGib_;
+}
+
+void CreateBundleRequest::setRootDiskSizeGib(int rootDiskSizeGib) {
+  rootDiskSizeGib_ = rootDiskSizeGib;
+  setParameter(std::string("RootDiskSizeGib"), std::to_string(rootDiskSizeGib));
+}
+

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

ecd/src/model/CreateDesktopGroupRequest.cc

@@ -0,0 +1,341 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/CreateDesktopGroupRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateDesktopGroupRequest;
+
+CreateDesktopGroupRequest::CreateDesktopGroupRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateDesktopGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateDesktopGroupRequest::~CreateDesktopGroupRequest() {}
+
+std::string CreateDesktopGroupRequest::getDesktopGroupName() const {
+  return desktopGroupName_;
+}
+
+void CreateDesktopGroupRequest::setDesktopGroupName(const std::string &desktopGroupName) {
+  desktopGroupName_ = desktopGroupName;
+  setParameter(std::string("DesktopGroupName"), desktopGroupName);
+}
+
+int CreateDesktopGroupRequest::getAllowBufferCount() const {
+  return allowBufferCount_;
+}
+
+void CreateDesktopGroupRequest::setAllowBufferCount(int allowBufferCount) {
+  allowBufferCount_ = allowBufferCount;
+  setParameter(std::string("AllowBufferCount"), std::to_string(allowBufferCount));
+}
+
+bool CreateDesktopGroupRequest::getAllClassifyUsers() const {
+  return allClassifyUsers_;
+}
+
+void CreateDesktopGroupRequest::setAllClassifyUsers(bool allClassifyUsers) {
+  allClassifyUsers_ = allClassifyUsers;
+  setParameter(std::string("AllClassifyUsers"), allClassifyUsers ? "true" : "false");
+}
+
+int CreateDesktopGroupRequest::getMaxDesktopsCount() const {
+  return maxDesktopsCount_;
+}
+
+void CreateDesktopGroupRequest::setMaxDesktopsCount(int maxDesktopsCount) {
+  maxDesktopsCount_ = maxDesktopsCount;
+  setParameter(std::string("MaxDesktopsCount"), std::to_string(maxDesktopsCount));
+}
+
+bool CreateDesktopGroupRequest::getVolumeEncryptionEnabled() const {
+  return volumeEncryptionEnabled_;
+}
+
+void CreateDesktopGroupRequest::setVolumeEncryptionEnabled(bool volumeEncryptionEnabled) {
+  volumeEncryptionEnabled_ = volumeEncryptionEnabled;
+  setParameter(std::string("VolumeEncryptionEnabled"), volumeEncryptionEnabled ? "true" : "false");
+}
+
+int CreateDesktopGroupRequest::getPeriod() const {
+  return period_;
+}
+
+void CreateDesktopGroupRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
+}
+
+int CreateDesktopGroupRequest::getAllowAutoSetup() const {
+  return allowAutoSetup_;
+}
+
+void CreateDesktopGroupRequest::setAllowAutoSetup(int allowAutoSetup) {
+  allowAutoSetup_ = allowAutoSetup;
+  setParameter(std::string("AllowAutoSetup"), std::to_string(allowAutoSetup));
+}
+
+long CreateDesktopGroupRequest::getResetType() const {
+  return resetType_;
+}
+
+void CreateDesktopGroupRequest::setResetType(long resetType) {
+  resetType_ = resetType;
+  setParameter(std::string("ResetType"), std::to_string(resetType));
+}
+
+float CreateDesktopGroupRequest::getRatioThreshold() const {
+  return ratioThreshold_;
+}
+
+void CreateDesktopGroupRequest::setRatioThreshold(float ratioThreshold) {
+  ratioThreshold_ = ratioThreshold;
+  setParameter(std::string("RatioThreshold"), std::to_string(ratioThreshold));
+}
+
+long CreateDesktopGroupRequest::getKeepDuration() const {
+  return keepDuration_;
+}
+
+void CreateDesktopGroupRequest::setKeepDuration(long keepDuration) {
+  keepDuration_ = keepDuration;
+  setParameter(std::string("KeepDuration"), std::to_string(keepDuration));
+}
+
+std::string CreateDesktopGroupRequest::getPeriodUnit() const {
+  return periodUnit_;
+}
+
+void CreateDesktopGroupRequest::setPeriodUnit(const std::string &periodUnit) {
+  periodUnit_ = periodUnit;
+  setParameter(std::string("PeriodUnit"), periodUnit);
+}
+
+bool CreateDesktopGroupRequest::getProfileFollowSwitch() const {
+  return profileFollowSwitch_;
+}
+
+void CreateDesktopGroupRequest::setProfileFollowSwitch(bool profileFollowSwitch) {
+  profileFollowSwitch_ = profileFollowSwitch;
+  setParameter(std::string("ProfileFollowSwitch"), profileFollowSwitch ? "true" : "false");
+}
+
+std::string CreateDesktopGroupRequest::getPolicyGroupId() const {
+  return policyGroupId_;
+}
+
+void CreateDesktopGroupRequest::setPolicyGroupId(const std::string &policyGroupId) {
+  policyGroupId_ = policyGroupId;
+  setParameter(std::string("PolicyGroupId"), policyGroupId);
+}
+
+std::string CreateDesktopGroupRequest::getVolumeEncryptionKey() const {
+  return volumeEncryptionKey_;
+}
+
+void CreateDesktopGroupRequest::setVolumeEncryptionKey(const std::string &volumeEncryptionKey) {
+  volumeEncryptionKey_ = volumeEncryptionKey;
+  setParameter(std::string("VolumeEncryptionKey"), volumeEncryptionKey);
+}
+
+std::string CreateDesktopGroupRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void CreateDesktopGroupRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::string CreateDesktopGroupRequest::getClassify() const {
+  return classify_;
+}
+
+void CreateDesktopGroupRequest::setClassify(const std::string &classify) {
+  classify_ = classify;
+  setParameter(std::string("Classify"), classify);
+}
+
+std::vector<std::string> CreateDesktopGroupRequest::getEndUserIds() const {
+  return endUserIds_;
+}
+
+void CreateDesktopGroupRequest::setEndUserIds(const std::vector<std::string> &endUserIds) {
+  endUserIds_ = endUserIds;
+}
+
+std::string CreateDesktopGroupRequest::getScaleStrategyId() const {
+  return scaleStrategyId_;
+}
+
+void CreateDesktopGroupRequest::setScaleStrategyId(const std::string &scaleStrategyId) {
+  scaleStrategyId_ = scaleStrategyId;
+  setParameter(std::string("ScaleStrategyId"), scaleStrategyId);
+}
+
+std::string CreateDesktopGroupRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateDesktopGroupRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateDesktopGroupRequest::getBundleId() const {
+  return bundleId_;
+}
+
+void CreateDesktopGroupRequest::setBundleId(const std::string &bundleId) {
+  bundleId_ = bundleId;
+  setParameter(std::string("BundleId"), bundleId);
+}
+
+long CreateDesktopGroupRequest::getBindAmount() const {
+  return bindAmount_;
+}
+
+void CreateDesktopGroupRequest::setBindAmount(long bindAmount) {
+  bindAmount_ = bindAmount;
+  setParameter(std::string("BindAmount"), std::to_string(bindAmount));
+}
+
+long CreateDesktopGroupRequest::getLoadPolicy() const {
+  return loadPolicy_;
+}
+
+void CreateDesktopGroupRequest::setLoadPolicy(long loadPolicy) {
+  loadPolicy_ = loadPolicy;
+  setParameter(std::string("LoadPolicy"), std::to_string(loadPolicy));
+}
+
+int CreateDesktopGroupRequest::getDefaultInitDesktopCount() const {
+  return defaultInitDesktopCount_;
+}
+
+void CreateDesktopGroupRequest::setDefaultInitDesktopCount(int defaultInitDesktopCount) {
+  defaultInitDesktopCount_ = defaultInitDesktopCount;
+  setParameter(std::string("DefaultInitDesktopCount"), std::to_string(defaultInitDesktopCount));
+}
+
+long CreateDesktopGroupRequest::getIdleDisconnectDuration() const {
+  return idleDisconnectDuration_;
+}
+
+void CreateDesktopGroupRequest::setIdleDisconnectDuration(long idleDisconnectDuration) {
+  idleDisconnectDuration_ = idleDisconnectDuration;
+  setParameter(std::string("IdleDisconnectDuration"), std::to_string(idleDisconnectDuration));
+}
+
+std::string CreateDesktopGroupRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateDesktopGroupRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateDesktopGroupRequest::getDirectoryId() const {
+  return directoryId_;
+}
+
+void CreateDesktopGroupRequest::setDirectoryId(const std::string &directoryId) {
+  directoryId_ = directoryId;
+  setParameter(std::string("DirectoryId"), directoryId);
+}
+
+int CreateDesktopGroupRequest::getMinDesktopsCount() const {
+  return minDesktopsCount_;
+}
+
+void CreateDesktopGroupRequest::setMinDesktopsCount(int minDesktopsCount) {
+  minDesktopsCount_ = minDesktopsCount;
+  setParameter(std::string("MinDesktopsCount"), std::to_string(minDesktopsCount));
+}
+
+std::string CreateDesktopGroupRequest::getFileSystemId() const {
+  return fileSystemId_;
+}
+
+void CreateDesktopGroupRequest::setFileSystemId(const std::string &fileSystemId) {
+  fileSystemId_ = fileSystemId;
+  setParameter(std::string("FileSystemId"), fileSystemId);
+}
+
+bool CreateDesktopGroupRequest::getAutoPay() const {
+  return autoPay_;
+}
+
+void CreateDesktopGroupRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
+}
+
+std::string CreateDesktopGroupRequest::getComments() const {
+  return comments_;
+}
+
+void CreateDesktopGroupRequest::setComments(const std::string &comments) {
+  comments_ = comments;
+  setParameter(std::string("Comments"), comments);
+}
+
+int CreateDesktopGroupRequest::getOwnType() const {
+  return ownType_;
+}
+
+void CreateDesktopGroupRequest::setOwnType(int ownType) {
+  ownType_ = ownType;
+  setParameter(std::string("OwnType"), std::to_string(ownType));
+}
+
+long CreateDesktopGroupRequest::getStopDuration() const {
+  return stopDuration_;
+}
+
+void CreateDesktopGroupRequest::setStopDuration(long stopDuration) {
+  stopDuration_ = stopDuration;
+  setParameter(std::string("StopDuration"), std::to_string(stopDuration));
+}
+
+long CreateDesktopGroupRequest::getConnectDuration() const {
+  return connectDuration_;
+}
+
+void CreateDesktopGroupRequest::setConnectDuration(long connectDuration) {
+  connectDuration_ = connectDuration;
+  setParameter(std::string("ConnectDuration"), std::to_string(connectDuration));
+}
+
+std::string CreateDesktopGroupRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateDesktopGroupRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string CreateDesktopGroupRequest::getChargeType() const {
+  return chargeType_;
+}
+
+void CreateDesktopGroupRequest::setChargeType(const std::string &chargeType) {
+  chargeType_ = chargeType;
+  setParameter(std::string("ChargeType"), chargeType);
+}
+

ecd/src/model/CreateDesktopGroupResult.cc

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/CreateDesktopGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+CreateDesktopGroupResult::CreateDesktopGroupResult() :
+	ServiceResult()
+{}
+
+CreateDesktopGroupResult::CreateDesktopGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDesktopGroupResult::~CreateDesktopGroupResult()
+{}
+
+void CreateDesktopGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allOrderIds = value["OrderIds"]["OrderId"];
+	for (const auto &item : allOrderIds)
+		orderIds_.push_back(item.asString());
+	if(!value["DesktopGroupId"].isNull())
+		desktopGroupId_ = value["DesktopGroupId"].asString();
+
+}
+
+std::string CreateDesktopGroupResult::getDesktopGroupId()const
+{
+	return desktopGroupId_;
+}
+
+std::vector<std::string> CreateDesktopGroupResult::getOrderIds()const
+{
+	return orderIds_;
+}
+

ecd/src/model/CreateDesktopsRequest.cc

@@ -0,0 +1,289 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/CreateDesktopsRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateDesktopsRequest;
+
+CreateDesktopsRequest::CreateDesktopsRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateDesktops") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateDesktopsRequest::~CreateDesktopsRequest() {}
+
+std::string CreateDesktopsRequest::getVolumeEncryptionKey() const {
+  return volumeEncryptionKey_;
+}
+
+void CreateDesktopsRequest::setVolumeEncryptionKey(const std::string &volumeEncryptionKey) {
+  volumeEncryptionKey_ = volumeEncryptionKey;
+  setParameter(std::string("VolumeEncryptionKey"), volumeEncryptionKey);
+}
+
+std::string CreateDesktopsRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void CreateDesktopsRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::string CreateDesktopsRequest::getImageId() const {
+  return imageId_;
+}
+
+void CreateDesktopsRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+std::string CreateDesktopsRequest::getBundleId() const {
+  return bundleId_;
+}
+
+void CreateDesktopsRequest::setBundleId(const std::string &bundleId) {
+  bundleId_ = bundleId;
+  setParameter(std::string("BundleId"), bundleId);
+}
+
+std::string CreateDesktopsRequest::getUserAssignMode() const {
+  return userAssignMode_;
+}
+
+void CreateDesktopsRequest::setUserAssignMode(const std::string &userAssignMode) {
+  userAssignMode_ = userAssignMode;
+  setParameter(std::string("UserAssignMode"), userAssignMode);
+}
+
+std::string CreateDesktopsRequest::getHostname() const {
+  return hostname_;
+}
+
+void CreateDesktopsRequest::setHostname(const std::string &hostname) {
+  hostname_ = hostname;
+  setParameter(std::string("Hostname"), hostname);
+}
+
+std::string CreateDesktopsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateDesktopsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool CreateDesktopsRequest::getDesktopNameSuffix() const {
+  return desktopNameSuffix_;
+}
+
+void CreateDesktopsRequest::setDesktopNameSuffix(bool desktopNameSuffix) {
+  desktopNameSuffix_ = desktopNameSuffix;
+  setParameter(std::string("DesktopNameSuffix"), desktopNameSuffix ? "true" : "false");
+}
+
+std::string CreateDesktopsRequest::getSystemDiskSize() const {
+  return systemDiskSize_;
+}
+
+void CreateDesktopsRequest::setSystemDiskSize(const std::string &systemDiskSize) {
+  systemDiskSize_ = systemDiskSize;
+  setParameter(std::string("SystemDiskSize"), systemDiskSize);
+}
+
+std::string CreateDesktopsRequest::getDirectoryId() const {
+  return directoryId_;
+}
+
+void CreateDesktopsRequest::setDirectoryId(const std::string &directoryId) {
+  directoryId_ = directoryId;
+  setParameter(std::string("DirectoryId"), directoryId);
+}
+
+std::vector<std::string> CreateDesktopsRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void CreateDesktopsRequest::setEndUserId(const std::vector<std::string> &endUserId) {
+  endUserId_ = endUserId;
+}
+
+std::vector<CreateDesktopsRequest::Tag> CreateDesktopsRequest::getTag() const {
+  return tag_;
+}
+
+void CreateDesktopsRequest::setTag(const std::vector<CreateDesktopsRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+bool CreateDesktopsRequest::getVolumeEncryptionEnabled() const {
+  return volumeEncryptionEnabled_;
+}
+
+void CreateDesktopsRequest::setVolumeEncryptionEnabled(bool volumeEncryptionEnabled) {
+  volumeEncryptionEnabled_ = volumeEncryptionEnabled;
+  setParameter(std::string("VolumeEncryptionEnabled"), volumeEncryptionEnabled ? "true" : "false");
+}
+
+std::string CreateDesktopsRequest::getDesktopName() const {
+  return desktopName_;
+}
+
+void CreateDesktopsRequest::setDesktopName(const std::string &desktopName) {
+  desktopName_ = desktopName;
+  setParameter(std::string("DesktopName"), desktopName);
+}
+
+int CreateDesktopsRequest::getAmount() const {
+  return amount_;
+}
+
+void CreateDesktopsRequest::setAmount(int amount) {
+  amount_ = amount;
+  setParameter(std::string("Amount"), std::to_string(amount));
+}
+
+int CreateDesktopsRequest::getPeriod() const {
+  return period_;
+}
+
+void CreateDesktopsRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
+}
+
+bool CreateDesktopsRequest::getAutoPay() const {
+  return autoPay_;
+}
+
+void CreateDesktopsRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
+}
+
+std::vector<CreateDesktopsRequest::UserCommands> CreateDesktopsRequest::getUserCommands() const {
+  return userCommands_;
+}
+
+void CreateDesktopsRequest::setUserCommands(const std::vector<CreateDesktopsRequest::UserCommands> &userCommands) {
+  userCommands_ = userCommands;
+  for(int dep1 = 0; dep1 != userCommands.size(); dep1++) {
+  auto userCommandsObj = userCommands.at(dep1);
+  std::string userCommandsObjStr = std::string("UserCommands") + "." + std::to_string(dep1 + 1);
+    setParameter(userCommandsObjStr + ".ContentEncoding", userCommandsObj.contentEncoding);
+    setParameter(userCommandsObjStr + ".Content", userCommandsObj.content);
+    setParameter(userCommandsObjStr + ".ContentType", userCommandsObj.contentType);
+  }
+}
+
+std::string CreateDesktopsRequest::getGroupId() const {
+  return groupId_;
+}
+
+void CreateDesktopsRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), groupId);
+}
+
+std::string CreateDesktopsRequest::getEcsInstanceType() const {
+  return ecsInstanceType_;
+}
+
+void CreateDesktopsRequest::setEcsInstanceType(const std::string &ecsInstanceType) {
+  ecsInstanceType_ = ecsInstanceType;
+  setParameter(std::string("EcsInstanceType"), ecsInstanceType);
+}
+
+std::string CreateDesktopsRequest::getPromotionId() const {
+  return promotionId_;
+}
+
+void CreateDesktopsRequest::setPromotionId(const std::string &promotionId) {
+  promotionId_ = promotionId;
+  setParameter(std::string("PromotionId"), promotionId);
+}
+
+std::string CreateDesktopsRequest::getPeriodUnit() const {
+  return periodUnit_;
+}
+
+void CreateDesktopsRequest::setPeriodUnit(const std::string &periodUnit) {
+  periodUnit_ = periodUnit;
+  setParameter(std::string("PeriodUnit"), periodUnit);
+}
+
+bool CreateDesktopsRequest::getAutoRenew() const {
+  return autoRenew_;
+}
+
+void CreateDesktopsRequest::setAutoRenew(bool autoRenew) {
+  autoRenew_ = autoRenew;
+  setParameter(std::string("AutoRenew"), autoRenew ? "true" : "false");
+}
+
+std::string CreateDesktopsRequest::getDataDiskSize() const {
+  return dataDiskSize_;
+}
+
+void CreateDesktopsRequest::setDataDiskSize(const std::string &dataDiskSize) {
+  dataDiskSize_ = dataDiskSize;
+  setParameter(std::string("DataDiskSize"), dataDiskSize);
+}
+
+std::string CreateDesktopsRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateDesktopsRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string CreateDesktopsRequest::getChargeType() const {
+  return chargeType_;
+}
+
+void CreateDesktopsRequest::setChargeType(const std::string &chargeType) {
+  chargeType_ = chargeType;
+  setParameter(std::string("ChargeType"), chargeType);
+}
+
+std::string CreateDesktopsRequest::getPolicyGroupId() const {
+  return policyGroupId_;
+}
+
+void CreateDesktopsRequest::setPolicyGroupId(const std::string &policyGroupId) {
+  policyGroupId_ = policyGroupId;
+  setParameter(std::string("PolicyGroupId"), policyGroupId);
+}
+
+std::string CreateDesktopsRequest::getUserName() const {
+  return userName_;
+}
+
+void CreateDesktopsRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setParameter(std::string("UserName"), userName);
+}
+

ecd/src/model/CreateDesktopsResult.cc

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/CreateDesktopsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+CreateDesktopsResult::CreateDesktopsResult() :
+	ServiceResult()
+{}
+
+CreateDesktopsResult::CreateDesktopsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDesktopsResult::~CreateDesktopsResult()
+{}
+
+void CreateDesktopsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDesktopId = value["DesktopId"]["DesktopIds"];
+	for (const auto &item : allDesktopId)
+		desktopId_.push_back(item.asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+
+}
+
+std::vector<std::string> CreateDesktopsResult::getDesktopId()const
+{
+	return desktopId_;
+}
+
+std::string CreateDesktopsResult::getOrderId()const
+{
+	return orderId_;
+}
+

ecd/src/model/CreateDiskEncryptionServiceRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/CreateDiskEncryptionServiceRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateDiskEncryptionServiceRequest;
+
+CreateDiskEncryptionServiceRequest::CreateDiskEncryptionServiceRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateDiskEncryptionService") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateDiskEncryptionServiceRequest::~CreateDiskEncryptionServiceRequest() {}
+
+std::string CreateDiskEncryptionServiceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateDiskEncryptionServiceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

ecd/src/model/CreateDiskEncryptionServiceResult.cc

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

ecd/src/model/CreateDriveRequest.cc

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/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

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/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/CreateImageRequest.cc

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecd/model/CreateImageRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateImageRequest;
+
+CreateImageRequest::CreateImageRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateImage") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateImageRequest::~CreateImageRequest() {}
+
+std::string CreateImageRequest::getSnapshotId() const {
+  return snapshotId_;
+}
+
+void CreateImageRequest::setSnapshotId(const std::string &snapshotId) {
+  snapshotId_ = snapshotId;
+  setParameter(std::string("SnapshotId"), snapshotId);
+}
+
+std::vector<std::string> CreateImageRequest::getSnapshotIds() const {
+  return snapshotIds_;
+}
+
+void CreateImageRequest::setSnapshotIds(const std::vector<std::string> &snapshotIds) {
+  snapshotIds_ = snapshotIds;
+}
+
+std::string CreateImageRequest::getDescription() const {
+  return description_;
+}
+
+void CreateImageRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreateImageRequest::getDiskType() const {
+  return diskType_;
+}
+
+void CreateImageRequest::setDiskType(const std::string &diskType) {
+  diskType_ = diskType;
+  setParameter(std::string("DiskType"), diskType);
+}
+
+std::string CreateImageRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateImageRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateImageRequest::getImageName() const {
+  return imageName_;
+}
+
+void CreateImageRequest::setImageName(const std::string &imageName) {
+  imageName_ = imageName;
+  setParameter(std::string("ImageName"), imageName);
+}
+
+bool CreateImageRequest::getAutoCleanUserdata() const {
+  return autoCleanUserdata_;
+}
+
+void CreateImageRequest::setAutoCleanUserdata(bool autoCleanUserdata) {
+  autoCleanUserdata_ = autoCleanUserdata;
+  setParameter(std::string("AutoCleanUserdata"), autoCleanUserdata ? "true" : "false");
+}
+
+std::string CreateImageRequest::getDesktopId() const {
+  return desktopId_;
+}
+
+void CreateImageRequest::setDesktopId(const std::string &desktopId) {
+  desktopId_ = desktopId;
+  setParameter(std::string("DesktopId"), desktopId);
+}
+
+std::string CreateImageRequest::getImageResourceType() const {
+  return imageResourceType_;
+}
+
+void CreateImageRequest::setImageResourceType(const std::string &imageResourceType) {
+  imageResourceType_ = imageResourceType;
+  setParameter(std::string("ImageResourceType"), imageResourceType);
+}
+

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

ecd/src/model/CreateNASFileSystemRequest.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/CreateNASFileSystemRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateNASFileSystemRequest;
+
+CreateNASFileSystemRequest::CreateNASFileSystemRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateNASFileSystem") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateNASFileSystemRequest::~CreateNASFileSystemRequest() {}
+
+std::string CreateNASFileSystemRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void CreateNASFileSystemRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::string CreateNASFileSystemRequest::getDescription() const {
+  return description_;
+}
+
+void CreateNASFileSystemRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreateNASFileSystemRequest::getStorageType() const {
+  return storageType_;
+}
+
+void CreateNASFileSystemRequest::setStorageType(const std::string &storageType) {
+  storageType_ = storageType;
+  setParameter(std::string("StorageType"), storageType);
+}
+
+std::string CreateNASFileSystemRequest::getEncryptType() const {
+  return encryptType_;
+}
+
+void CreateNASFileSystemRequest::setEncryptType(const std::string &encryptType) {
+  encryptType_ = encryptType;
+  setParameter(std::string("EncryptType"), encryptType);
+}
+
+std::string CreateNASFileSystemRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateNASFileSystemRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateNASFileSystemRequest::getName() const {
+  return name_;
+}
+
+void CreateNASFileSystemRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+

ecd/src/model/CreateNASFileSystemResult.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/CreateNASFileSystemResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+CreateNASFileSystemResult::CreateNASFileSystemResult() :
+	ServiceResult()
+{}
+
+CreateNASFileSystemResult::CreateNASFileSystemResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateNASFileSystemResult::~CreateNASFileSystemResult()
+{}
+
+void CreateNASFileSystemResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["FileSystemId"].isNull())
+		fileSystemId_ = value["FileSystemId"].asString();
+	if(!value["FileSystemName"].isNull())
+		fileSystemName_ = value["FileSystemName"].asString();
+	if(!value["MountTargetDomain"].isNull())
+		mountTargetDomain_ = value["MountTargetDomain"].asString();
+	if(!value["OfficeSiteId"].isNull())
+		officeSiteId_ = value["OfficeSiteId"].asString();
+
+}
+
+std::string CreateNASFileSystemResult::getOfficeSiteId()const
+{
+	return officeSiteId_;
+}
+
+std::string CreateNASFileSystemResult::getMountTargetDomain()const
+{
+	return mountTargetDomain_;
+}
+
+std::string CreateNASFileSystemResult::getFileSystemId()const
+{
+	return fileSystemId_;
+}
+
+std::string CreateNASFileSystemResult::getFileSystemName()const
+{
+	return fileSystemName_;
+}
+

ecd/src/model/CreateNetworkPackageRequest.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/CreateNetworkPackageRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateNetworkPackageRequest;
+
+CreateNetworkPackageRequest::CreateNetworkPackageRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateNetworkPackage") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateNetworkPackageRequest::~CreateNetworkPackageRequest() {}
+
+std::string CreateNetworkPackageRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void CreateNetworkPackageRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+int CreateNetworkPackageRequest::getPeriod() const {
+  return period_;
+}
+
+void CreateNetworkPackageRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
+}
+
+bool CreateNetworkPackageRequest::getAutoPay() const {
+  return autoPay_;
+}
+
+void CreateNetworkPackageRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
+}
+
+int CreateNetworkPackageRequest::getBandwidth() const {
+  return bandwidth_;
+}
+
+void CreateNetworkPackageRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
+}
+
+std::string CreateNetworkPackageRequest::getPromotionId() const {
+  return promotionId_;
+}
+
+void CreateNetworkPackageRequest::setPromotionId(const std::string &promotionId) {
+  promotionId_ = promotionId;
+  setParameter(std::string("PromotionId"), promotionId);
+}
+
+std::string CreateNetworkPackageRequest::getPeriodUnit() const {
+  return periodUnit_;
+}
+
+void CreateNetworkPackageRequest::setPeriodUnit(const std::string &periodUnit) {
+  periodUnit_ = periodUnit;
+  setParameter(std::string("PeriodUnit"), periodUnit);
+}
+
+bool CreateNetworkPackageRequest::getAutoRenew() const {
+  return autoRenew_;
+}
+
+void CreateNetworkPackageRequest::setAutoRenew(bool autoRenew) {
+  autoRenew_ = 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_;
+}
+
+void CreateNetworkPackageRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
+}
+

ecd/src/model/CreateNetworkPackageResult.cc

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

ecd/src/model/CreatePolicyGroupRequest.cc

@@ -0,0 +1,344 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/CreatePolicyGroupRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreatePolicyGroupRequest;
+
+CreatePolicyGroupRequest::CreatePolicyGroupRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreatePolicyGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+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_;
+}
+
+void CreatePolicyGroupRequest::setRecordingExpires(long recordingExpires) {
+  recordingExpires_ = 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_;
+}
+
+void CreatePolicyGroupRequest::setPrinterRedirection(const std::string &printerRedirection) {
+  printerRedirection_ = printerRedirection;
+  setParameter(std::string("PrinterRedirection"), printerRedirection);
+}
+
+std::vector<std::string> CreatePolicyGroupRequest::getPreemptLoginUser() const {
+  return preemptLoginUser_;
+}
+
+void CreatePolicyGroupRequest::setPreemptLoginUser(const std::vector<std::string> &preemptLoginUser) {
+  preemptLoginUser_ = preemptLoginUser;
+}
+
+std::string CreatePolicyGroupRequest::getDomainList() const {
+  return domainList_;
+}
+
+void CreatePolicyGroupRequest::setDomainList(const std::string &domainList) {
+  domainList_ = domainList;
+  setParameter(std::string("DomainList"), domainList);
+}
+
+std::string CreatePolicyGroupRequest::getNetRedirect() const {
+  return netRedirect_;
+}
+
+void CreatePolicyGroupRequest::setNetRedirect(const std::string &netRedirect) {
+  netRedirect_ = netRedirect;
+  setParameter(std::string("NetRedirect"), netRedirect);
+}
+
+std::string CreatePolicyGroupRequest::getLocalDrive() const {
+  return localDrive_;
+}
+
+void CreatePolicyGroupRequest::setLocalDrive(const std::string &localDrive) {
+  localDrive_ = localDrive;
+  setParameter(std::string("LocalDrive"), localDrive);
+}
+
+std::vector<CreatePolicyGroupRequest::AuthorizeSecurityPolicyRule> CreatePolicyGroupRequest::getAuthorizeSecurityPolicyRule() const {
+  return authorizeSecurityPolicyRule_;
+}
+
+void CreatePolicyGroupRequest::setAuthorizeSecurityPolicyRule(const std::vector<CreatePolicyGroupRequest::AuthorizeSecurityPolicyRule> &authorizeSecurityPolicyRule) {
+  authorizeSecurityPolicyRule_ = authorizeSecurityPolicyRule;
+  for(int dep1 = 0; dep1 != authorizeSecurityPolicyRule.size(); dep1++) {
+  auto authorizeSecurityPolicyRuleObj = authorizeSecurityPolicyRule.at(dep1);
+  std::string authorizeSecurityPolicyRuleObjStr = std::string("AuthorizeSecurityPolicyRule") + "." + std::to_string(dep1 + 1);
+    setParameter(authorizeSecurityPolicyRuleObjStr + ".PortRange", authorizeSecurityPolicyRuleObj.portRange);
+    setParameter(authorizeSecurityPolicyRuleObjStr + ".IpProtocol", authorizeSecurityPolicyRuleObj.ipProtocol);
+    setParameter(authorizeSecurityPolicyRuleObjStr + ".Description", authorizeSecurityPolicyRuleObj.description);
+    setParameter(authorizeSecurityPolicyRuleObjStr + ".Type", authorizeSecurityPolicyRuleObj.type);
+    setParameter(authorizeSecurityPolicyRuleObjStr + ".Priority", authorizeSecurityPolicyRuleObj.priority);
+    setParameter(authorizeSecurityPolicyRuleObjStr + ".CidrIp", authorizeSecurityPolicyRuleObj.cidrIp);
+    setParameter(authorizeSecurityPolicyRuleObjStr + ".Policy", authorizeSecurityPolicyRuleObj.policy);
+  }
+}
+
+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_;
+}
+
+void CreatePolicyGroupRequest::setClipboard(const std::string &clipboard) {
+  clipboard_ = clipboard;
+  setParameter(std::string("Clipboard"), clipboard);
+}
+
+long CreatePolicyGroupRequest::getRecordingFps() const {
+  return recordingFps_;
+}
+
+void CreatePolicyGroupRequest::setRecordingFps(long recordingFps) {
+  recordingFps_ = recordingFps;
+  setParameter(std::string("RecordingFps"), std::to_string(recordingFps));
+}
+
+std::string CreatePolicyGroupRequest::getUsbRedirect() const {
+  return usbRedirect_;
+}
+
+void CreatePolicyGroupRequest::setUsbRedirect(const std::string &usbRedirect) {
+  usbRedirect_ = 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_;
+}
+
+void CreatePolicyGroupRequest::setWatermarkType(const std::string &watermarkType) {
+  watermarkType_ = watermarkType;
+  setParameter(std::string("WatermarkType"), watermarkType);
+}
+
+std::string CreatePolicyGroupRequest::getRecordingStartTime() const {
+  return recordingStartTime_;
+}
+
+void CreatePolicyGroupRequest::setRecordingStartTime(const std::string &recordingStartTime) {
+  recordingStartTime_ = recordingStartTime;
+  setParameter(std::string("RecordingStartTime"), recordingStartTime);
+}
+
+std::string CreatePolicyGroupRequest::getRecordContent() const {
+  return recordContent_;
+}
+
+void CreatePolicyGroupRequest::setRecordContent(const std::string &recordContent) {
+  recordContent_ = recordContent;
+  setParameter(std::string("RecordContent"), recordContent);
+}
+
+long CreatePolicyGroupRequest::getRecordContentExpires() const {
+  return recordContentExpires_;
+}
+
+void CreatePolicyGroupRequest::setRecordContentExpires(long recordContentExpires) {
+  recordContentExpires_ = recordContentExpires;
+  setParameter(std::string("RecordContentExpires"), std::to_string(recordContentExpires));
+}
+
+std::string CreatePolicyGroupRequest::getWatermark() const {
+  return watermark_;
+}
+
+void CreatePolicyGroupRequest::setWatermark(const std::string &watermark) {
+  watermark_ = watermark;
+  setParameter(std::string("Watermark"), watermark);
+}
+
+std::string CreatePolicyGroupRequest::getCameraRedirect() const {
+  return cameraRedirect_;
+}
+
+void CreatePolicyGroupRequest::setCameraRedirect(const std::string &cameraRedirect) {
+  cameraRedirect_ = cameraRedirect;
+  setParameter(std::string("CameraRedirect"), cameraRedirect);
+}
+
+std::string CreatePolicyGroupRequest::getRemoteCoordinate() const {
+  return remoteCoordinate_;
+}
+
+void CreatePolicyGroupRequest::setRemoteCoordinate(const std::string &remoteCoordinate) {
+  remoteCoordinate_ = remoteCoordinate;
+  setParameter(std::string("RemoteCoordinate"), remoteCoordinate);
+}
+
+std::string CreatePolicyGroupRequest::getHtml5Access() const {
+  return html5Access_;
+}
+
+void CreatePolicyGroupRequest::setHtml5Access(const std::string &html5Access) {
+  html5Access_ = html5Access;
+  setParameter(std::string("Html5Access"), html5Access);
+}
+
+std::string CreatePolicyGroupRequest::getGpuAcceleration() const {
+  return gpuAcceleration_;
+}
+
+void CreatePolicyGroupRequest::setGpuAcceleration(const std::string &gpuAcceleration) {
+  gpuAcceleration_ = gpuAcceleration;
+  setParameter(std::string("GpuAcceleration"), gpuAcceleration);
+}
+
+std::string CreatePolicyGroupRequest::getHtml5FileTransfer() const {
+  return html5FileTransfer_;
+}
+
+void CreatePolicyGroupRequest::setHtml5FileTransfer(const std::string &html5FileTransfer) {
+  html5FileTransfer_ = html5FileTransfer;
+  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_;
+}
+
+void CreatePolicyGroupRequest::setVisualQuality(const std::string &visualQuality) {
+  visualQuality_ = 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_;
+}
+
+void CreatePolicyGroupRequest::setRecordingEndTime(const std::string &recordingEndTime) {
+  recordingEndTime_ = recordingEndTime;
+  setParameter(std::string("RecordingEndTime"), recordingEndTime);
+}
+

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

ecd/src/model/CreateRAMDirectoryRequest.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/CreateRAMDirectoryRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateRAMDirectoryRequest;
+
+CreateRAMDirectoryRequest::CreateRAMDirectoryRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateRAMDirectory") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateRAMDirectoryRequest::~CreateRAMDirectoryRequest() {}
+
+std::string CreateRAMDirectoryRequest::getDesktopAccessType() const {
+  return desktopAccessType_;
+}
+
+void CreateRAMDirectoryRequest::setDesktopAccessType(const std::string &desktopAccessType) {
+  desktopAccessType_ = desktopAccessType;
+  setParameter(std::string("DesktopAccessType"), desktopAccessType);
+}
+
+bool CreateRAMDirectoryRequest::getEnableInternetAccess() const {
+  return enableInternetAccess_;
+}
+
+void CreateRAMDirectoryRequest::setEnableInternetAccess(bool enableInternetAccess) {
+  enableInternetAccess_ = enableInternetAccess;
+  setParameter(std::string("EnableInternetAccess"), enableInternetAccess ? "true" : "false");
+}
+
+std::string CreateRAMDirectoryRequest::getDirectoryName() const {
+  return directoryName_;
+}
+
+void CreateRAMDirectoryRequest::setDirectoryName(const std::string &directoryName) {
+  directoryName_ = directoryName;
+  setParameter(std::string("DirectoryName"), directoryName);
+}
+
+std::vector<std::string> CreateRAMDirectoryRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateRAMDirectoryRequest::setVSwitchId(const std::vector<std::string> &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+}
+
+std::string CreateRAMDirectoryRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateRAMDirectoryRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool CreateRAMDirectoryRequest::getEnableAdminAccess() const {
+  return enableAdminAccess_;
+}
+
+void CreateRAMDirectoryRequest::setEnableAdminAccess(bool enableAdminAccess) {
+  enableAdminAccess_ = enableAdminAccess;
+  setParameter(std::string("EnableAdminAccess"), enableAdminAccess ? "true" : "false");
+}
+

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

ecd/src/model/CreateSimpleOfficeSiteRequest.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/CreateSimpleOfficeSiteRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateSimpleOfficeSiteRequest;
+
+CreateSimpleOfficeSiteRequest::CreateSimpleOfficeSiteRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateSimpleOfficeSite") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateSimpleOfficeSiteRequest::~CreateSimpleOfficeSiteRequest() {}
+
+std::string CreateSimpleOfficeSiteRequest::getCenId() const {
+  return cenId_;
+}
+
+void CreateSimpleOfficeSiteRequest::setCenId(const std::string &cenId) {
+  cenId_ = cenId;
+  setParameter(std::string("CenId"), cenId);
+}
+
+long CreateSimpleOfficeSiteRequest::getCenOwnerId() const {
+  return cenOwnerId_;
+}
+
+void CreateSimpleOfficeSiteRequest::setCenOwnerId(long cenOwnerId) {
+  cenOwnerId_ = cenOwnerId;
+  setParameter(std::string("CenOwnerId"), std::to_string(cenOwnerId));
+}
+
+bool CreateSimpleOfficeSiteRequest::getEnableInternetAccess() const {
+  return enableInternetAccess_;
+}
+
+void CreateSimpleOfficeSiteRequest::setEnableInternetAccess(bool enableInternetAccess) {
+  enableInternetAccess_ = enableInternetAccess;
+  setParameter(std::string("EnableInternetAccess"), enableInternetAccess ? "true" : "false");
+}
+
+std::string CreateSimpleOfficeSiteRequest::getVerifyCode() const {
+  return verifyCode_;
+}
+
+void CreateSimpleOfficeSiteRequest::setVerifyCode(const std::string &verifyCode) {
+  verifyCode_ = verifyCode;
+  setParameter(std::string("VerifyCode"), verifyCode);
+}
+
+bool CreateSimpleOfficeSiteRequest::getNeedVerifyZeroDevice() const {
+  return needVerifyZeroDevice_;
+}
+
+void CreateSimpleOfficeSiteRequest::setNeedVerifyZeroDevice(bool needVerifyZeroDevice) {
+  needVerifyZeroDevice_ = needVerifyZeroDevice;
+  setParameter(std::string("NeedVerifyZeroDevice"), needVerifyZeroDevice ? "true" : "false");
+}
+
+std::string CreateSimpleOfficeSiteRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateSimpleOfficeSiteRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool CreateSimpleOfficeSiteRequest::getEnableAdminAccess() const {
+  return enableAdminAccess_;
+}
+
+void CreateSimpleOfficeSiteRequest::setEnableAdminAccess(bool enableAdminAccess) {
+  enableAdminAccess_ = enableAdminAccess;
+  setParameter(std::string("EnableAdminAccess"), enableAdminAccess ? "true" : "false");
+}
+
+int CreateSimpleOfficeSiteRequest::getBandwidth() const {
+  return bandwidth_;
+}
+
+void CreateSimpleOfficeSiteRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
+}
+
+std::string CreateSimpleOfficeSiteRequest::getDesktopAccessType() const {
+  return desktopAccessType_;
+}
+
+void CreateSimpleOfficeSiteRequest::setDesktopAccessType(const std::string &desktopAccessType) {
+  desktopAccessType_ = desktopAccessType;
+  setParameter(std::string("DesktopAccessType"), desktopAccessType);
+}
+
+std::string CreateSimpleOfficeSiteRequest::getOfficeSiteName() const {
+  return officeSiteName_;
+}
+
+void CreateSimpleOfficeSiteRequest::setOfficeSiteName(const std::string &officeSiteName) {
+  officeSiteName_ = officeSiteName;
+  setParameter(std::string("OfficeSiteName"), officeSiteName);
+}
+
+bool CreateSimpleOfficeSiteRequest::getCloudBoxOfficeSite() const {
+  return cloudBoxOfficeSite_;
+}
+
+void CreateSimpleOfficeSiteRequest::setCloudBoxOfficeSite(bool cloudBoxOfficeSite) {
+  cloudBoxOfficeSite_ = cloudBoxOfficeSite;
+  setParameter(std::string("CloudBoxOfficeSite"), cloudBoxOfficeSite ? "true" : "false");
+}
+
+std::vector<std::string> CreateSimpleOfficeSiteRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateSimpleOfficeSiteRequest::setVSwitchId(const std::vector<std::string> &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+}
+
+std::string CreateSimpleOfficeSiteRequest::getCidrBlock() const {
+  return cidrBlock_;
+}
+
+void CreateSimpleOfficeSiteRequest::setCidrBlock(const std::string &cidrBlock) {
+  cidrBlock_ = cidrBlock;
+  setParameter(std::string("CidrBlock"), cidrBlock);
+}
+

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

ecd/src/model/CreateSnapshotRequest.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/CreateSnapshotRequest.h>
+
+using AlibabaCloud::Ecd::Model::CreateSnapshotRequest;
+
+CreateSnapshotRequest::CreateSnapshotRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "CreateSnapshot") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateSnapshotRequest::~CreateSnapshotRequest() {}
+
+std::string CreateSnapshotRequest::getDescription() const {
+  return description_;
+}
+
+void CreateSnapshotRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreateSnapshotRequest::getSourceDiskType() const {
+  return sourceDiskType_;
+}
+
+void CreateSnapshotRequest::setSourceDiskType(const std::string &sourceDiskType) {
+  sourceDiskType_ = sourceDiskType;
+  setParameter(std::string("SourceDiskType"), sourceDiskType);
+}
+
+std::string CreateSnapshotRequest::getSnapshotName() const {
+  return snapshotName_;
+}
+
+void CreateSnapshotRequest::setSnapshotName(const std::string &snapshotName) {
+  snapshotName_ = snapshotName;
+  setParameter(std::string("SnapshotName"), snapshotName);
+}
+
+std::string CreateSnapshotRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateSnapshotRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateSnapshotRequest::getDesktopId() const {
+  return desktopId_;
+}
+
+void CreateSnapshotRequest::setDesktopId(const std::string &desktopId) {
+  desktopId_ = desktopId;
+  setParameter(std::string("DesktopId"), desktopId);
+}
+

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

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

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

ecd/src/model/DeleteCloudDriveUsersRequest.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/DeleteCloudDriveUsersRequest.h>
+
+using AlibabaCloud::Ecd::Model::DeleteCloudDriveUsersRequest;
+
+DeleteCloudDriveUsersRequest::DeleteCloudDriveUsersRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DeleteCloudDriveUsers") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteCloudDriveUsersRequest::~DeleteCloudDriveUsersRequest() {}
+
+std::string DeleteCloudDriveUsersRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void DeleteCloudDriveUsersRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string DeleteCloudDriveUsersRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteCloudDriveUsersRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> DeleteCloudDriveUsersRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void DeleteCloudDriveUsersRequest::setEndUserId(const std::vector<std::string> &endUserId) {
+  endUserId_ = endUserId;
+}
+

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

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

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

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

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

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

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

ecd/src/model/DeleteDriveRequest.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/DeleteDriveRequest.h>
+
+using AlibabaCloud::Ecd::Model::DeleteDriveRequest;
+
+DeleteDriveRequest::DeleteDriveRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DeleteDrive") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDriveRequest::~DeleteDriveRequest() {}
+
+std::string DeleteDriveRequest::getDriveId() const {
+  return driveId_;
+}
+
+void DeleteDriveRequest::setDriveId(const std::string &driveId) {
+  driveId_ = driveId;
+  setParameter(std::string("DriveId"), driveId);
+}
+
+std::string DeleteDriveRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteDriveRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

ecd/src/model/DeleteDriveResult.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/DeleteDriveResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DeleteDriveResult::DeleteDriveResult() :
+	ServiceResult()
+{}
+
+DeleteDriveResult::DeleteDriveResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteDriveResult::~DeleteDriveResult()
+{}
+
+void DeleteDriveResult::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["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString() == "true";
+
+}
+
+std::string DeleteDriveResult::getMessage()const
+{
+	return message_;
+}
+
+bool DeleteDriveResult::getData()const
+{
+	return data_;
+}
+
+std::string DeleteDriveResult::getCode()const
+{
+	return code_;
+}
+
+bool DeleteDriveResult::getSuccess()const
+{
+	return success_;
+}
+

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

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

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

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

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

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

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

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

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

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

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

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

ecd/src/model/DeleteVirtualMFADeviceRequest.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/DeleteVirtualMFADeviceRequest.h>
+
+using AlibabaCloud::Ecd::Model::DeleteVirtualMFADeviceRequest;
+
+DeleteVirtualMFADeviceRequest::DeleteVirtualMFADeviceRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DeleteVirtualMFADevice") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteVirtualMFADeviceRequest::~DeleteVirtualMFADeviceRequest() {}
+
+std::string DeleteVirtualMFADeviceRequest::getSerialNumber() const {
+  return serialNumber_;
+}
+
+void DeleteVirtualMFADeviceRequest::setSerialNumber(const std::string &serialNumber) {
+  serialNumber_ = serialNumber;
+  setParameter(std::string("SerialNumber"), serialNumber);
+}
+
+std::string DeleteVirtualMFADeviceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteVirtualMFADeviceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

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

ecd/src/model/DescribeAlarmEventStackInfoRequest.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/DescribeAlarmEventStackInfoRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeAlarmEventStackInfoRequest;
+
+DescribeAlarmEventStackInfoRequest::DescribeAlarmEventStackInfoRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeAlarmEventStackInfo") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeAlarmEventStackInfoRequest::~DescribeAlarmEventStackInfoRequest() {}
+
+std::string DescribeAlarmEventStackInfoRequest::getUniqueInfo() const {
+  return uniqueInfo_;
+}
+
+void DescribeAlarmEventStackInfoRequest::setUniqueInfo(const std::string &uniqueInfo) {
+  uniqueInfo_ = uniqueInfo;
+  setParameter(std::string("UniqueInfo"), uniqueInfo);
+}
+
+std::string DescribeAlarmEventStackInfoRequest::getEventName() const {
+  return eventName_;
+}
+
+void DescribeAlarmEventStackInfoRequest::setEventName(const std::string &eventName) {
+  eventName_ = eventName;
+  setParameter(std::string("EventName"), eventName);
+}
+
+std::string DescribeAlarmEventStackInfoRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeAlarmEventStackInfoRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeAlarmEventStackInfoRequest::getDesktopId() const {
+  return desktopId_;
+}
+
+void DescribeAlarmEventStackInfoRequest::setDesktopId(const std::string &desktopId) {
+  desktopId_ = desktopId;
+  setParameter(std::string("DesktopId"), desktopId);
+}
+
+std::string DescribeAlarmEventStackInfoRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeAlarmEventStackInfoRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+

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

ecd/src/model/DescribeBundlesRequest.cc

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeBundlesRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeBundlesRequest;
+
+DescribeBundlesRequest::DescribeBundlesRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeBundles") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeBundlesRequest::~DescribeBundlesRequest() {}
+
+float DescribeBundlesRequest::getGpuCount() const {
+  return gpuCount_;
+}
+
+void DescribeBundlesRequest::setGpuCount(float gpuCount) {
+  gpuCount_ = gpuCount;
+  setParameter(std::string("GpuCount"), std::to_string(gpuCount));
+}
+
+std::vector<std::string> DescribeBundlesRequest::getBundleId() const {
+  return bundleId_;
+}
+
+void DescribeBundlesRequest::setBundleId(const std::vector<std::string> &bundleId) {
+  bundleId_ = bundleId;
+}
+
+std::string DescribeBundlesRequest::getDesktopTypeFamily() const {
+  return desktopTypeFamily_;
+}
+
+void DescribeBundlesRequest::setDesktopTypeFamily(const std::string &desktopTypeFamily) {
+  desktopTypeFamily_ = desktopTypeFamily;
+  setParameter(std::string("DesktopTypeFamily"), desktopTypeFamily);
+}
+
+std::string DescribeBundlesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeBundlesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeBundlesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeBundlesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+bool DescribeBundlesRequest::getFromDesktopGroup() const {
+  return fromDesktopGroup_;
+}
+
+void DescribeBundlesRequest::setFromDesktopGroup(bool fromDesktopGroup) {
+  fromDesktopGroup_ = fromDesktopGroup;
+  setParameter(std::string("FromDesktopGroup"), fromDesktopGroup ? "true" : "false");
+}
+
+std::string DescribeBundlesRequest::getBundleType() const {
+  return bundleType_;
+}
+
+void DescribeBundlesRequest::setBundleType(const std::string &bundleType) {
+  bundleType_ = bundleType;
+  setParameter(std::string("BundleType"), bundleType);
+}
+
+std::string DescribeBundlesRequest::getFotaChannel() const {
+  return fotaChannel_;
+}
+
+void DescribeBundlesRequest::setFotaChannel(const std::string &fotaChannel) {
+  fotaChannel_ = fotaChannel;
+  setParameter(std::string("FotaChannel"), fotaChannel);
+}
+
+bool DescribeBundlesRequest::getVolumeEncryptionEnabled() const {
+  return volumeEncryptionEnabled_;
+}
+
+void DescribeBundlesRequest::setVolumeEncryptionEnabled(bool volumeEncryptionEnabled) {
+  volumeEncryptionEnabled_ = volumeEncryptionEnabled;
+  setParameter(std::string("VolumeEncryptionEnabled"), volumeEncryptionEnabled ? "true" : "false");
+}
+
+int DescribeBundlesRequest::getMemorySize() const {
+  return memorySize_;
+}
+
+void DescribeBundlesRequest::setMemorySize(int memorySize) {
+  memorySize_ = memorySize;
+  setParameter(std::string("MemorySize"), std::to_string(memorySize));
+}
+
+int DescribeBundlesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeBundlesRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+bool DescribeBundlesRequest::getCheckStock() const {
+  return checkStock_;
+}
+
+void DescribeBundlesRequest::setCheckStock(bool checkStock) {
+  checkStock_ = checkStock;
+  setParameter(std::string("CheckStock"), checkStock ? "true" : "false");
+}
+
+std::string DescribeBundlesRequest::getProtocolType() const {
+  return protocolType_;
+}
+
+void DescribeBundlesRequest::setProtocolType(const std::string &protocolType) {
+  protocolType_ = protocolType;
+  setParameter(std::string("ProtocolType"), protocolType);
+}
+
+int DescribeBundlesRequest::getCpuCount() const {
+  return cpuCount_;
+}
+
+void DescribeBundlesRequest::setCpuCount(int cpuCount) {
+  cpuCount_ = cpuCount;
+  setParameter(std::string("CpuCount"), std::to_string(cpuCount));
+}
+
+bool DescribeBundlesRequest::getSupportMultiSession() const {
+  return supportMultiSession_;
+}
+
+void DescribeBundlesRequest::setSupportMultiSession(bool supportMultiSession) {
+  supportMultiSession_ = supportMultiSession;
+  setParameter(std::string("SupportMultiSession"), supportMultiSession ? "true" : "false");
+}
+

ecd/src/model/DescribeBundlesResult.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/DescribeBundlesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeBundlesResult::DescribeBundlesResult() :
+	ServiceResult()
+{}
+
+DescribeBundlesResult::DescribeBundlesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeBundlesResult::~DescribeBundlesResult()
+{}
+
+void DescribeBundlesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allBundlesNode = value["Bundles"]["Bundle"];
+	for (auto valueBundlesBundle : allBundlesNode)
+	{
+		Bundle bundlesObject;
+		if(!valueBundlesBundle["Description"].isNull())
+			bundlesObject.description = valueBundlesBundle["Description"].asString();
+		if(!valueBundlesBundle["BundleType"].isNull())
+			bundlesObject.bundleType = valueBundlesBundle["BundleType"].asString();
+		if(!valueBundlesBundle["OsType"].isNull())
+			bundlesObject.osType = valueBundlesBundle["OsType"].asString();
+		if(!valueBundlesBundle["StockState"].isNull())
+			bundlesObject.stockState = valueBundlesBundle["StockState"].asString();
+		if(!valueBundlesBundle["DesktopType"].isNull())
+			bundlesObject.desktopType = valueBundlesBundle["DesktopType"].asString();
+		if(!valueBundlesBundle["ProtocolType"].isNull())
+			bundlesObject.protocolType = valueBundlesBundle["ProtocolType"].asString();
+		if(!valueBundlesBundle["BundleId"].isNull())
+			bundlesObject.bundleId = valueBundlesBundle["BundleId"].asString();
+		if(!valueBundlesBundle["ImageId"].isNull())
+			bundlesObject.imageId = valueBundlesBundle["ImageId"].asString();
+		if(!valueBundlesBundle["ImageName"].isNull())
+			bundlesObject.imageName = valueBundlesBundle["ImageName"].asString();
+		if(!valueBundlesBundle["Language"].isNull())
+			bundlesObject.language = valueBundlesBundle["Language"].asString();
+		if(!valueBundlesBundle["BundleName"].isNull())
+			bundlesObject.bundleName = valueBundlesBundle["BundleName"].asString();
+		if(!valueBundlesBundle["DesktopTypeFamily"].isNull())
+			bundlesObject.desktopTypeFamily = valueBundlesBundle["DesktopTypeFamily"].asString();
+		if(!valueBundlesBundle["CreationTime"].isNull())
+			bundlesObject.creationTime = valueBundlesBundle["CreationTime"].asString();
+		if(!valueBundlesBundle["SessionType"].isNull())
+			bundlesObject.sessionType = valueBundlesBundle["SessionType"].asString();
+		if(!valueBundlesBundle["VolumeEncryptionEnabled"].isNull())
+			bundlesObject.volumeEncryptionEnabled = valueBundlesBundle["VolumeEncryptionEnabled"].asString() == "true";
+		if(!valueBundlesBundle["VolumeEncryptionKey"].isNull())
+			bundlesObject.volumeEncryptionKey = valueBundlesBundle["VolumeEncryptionKey"].asString();
+		if(!valueBundlesBundle["Platform"].isNull())
+			bundlesObject.platform = valueBundlesBundle["Platform"].asString();
+		auto allDisksNode = valueBundlesBundle["Disks"]["Disk"];
+		for (auto valueBundlesBundleDisksDisk : allDisksNode)
+		{
+			Bundle::Disk disksObject;
+			if(!valueBundlesBundleDisksDisk["DiskType"].isNull())
+				disksObject.diskType = valueBundlesBundleDisksDisk["DiskType"].asString();
+			if(!valueBundlesBundleDisksDisk["DiskSize"].isNull())
+				disksObject.diskSize = std::stoi(valueBundlesBundleDisksDisk["DiskSize"].asString());
+			if(!valueBundlesBundleDisksDisk["DiskPerformanceLevel"].isNull())
+				disksObject.diskPerformanceLevel = valueBundlesBundleDisksDisk["DiskPerformanceLevel"].asString();
+			bundlesObject.disks.push_back(disksObject);
+		}
+		auto desktopTypeAttributeNode = value["DesktopTypeAttribute"];
+		if(!desktopTypeAttributeNode["CpuCount"].isNull())
+			bundlesObject.desktopTypeAttribute.cpuCount = std::stoi(desktopTypeAttributeNode["CpuCount"].asString());
+		if(!desktopTypeAttributeNode["GpuCount"].isNull())
+			bundlesObject.desktopTypeAttribute.gpuCount = std::stof(desktopTypeAttributeNode["GpuCount"].asString());
+		if(!desktopTypeAttributeNode["GpuSpec"].isNull())
+			bundlesObject.desktopTypeAttribute.gpuSpec = desktopTypeAttributeNode["GpuSpec"].asString();
+		if(!desktopTypeAttributeNode["MemorySize"].isNull())
+			bundlesObject.desktopTypeAttribute.memorySize = std::stoi(desktopTypeAttributeNode["MemorySize"].asString());
+		bundles_.push_back(bundlesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::string DescribeBundlesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<DescribeBundlesResult::Bundle> DescribeBundlesResult::getBundles()const
+{
+	return bundles_;
+}
+

ecd/src/model/DescribeCensRequest.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/DescribeCensRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeCensRequest;
+
+DescribeCensRequest::DescribeCensRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeCens") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCensRequest::~DescribeCensRequest() {}
+
+int DescribeCensRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeCensRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeCensRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeCensRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeCensRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeCensRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+

ecd/src/model/DescribeCensResult.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/DescribeCensResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeCensResult::DescribeCensResult() :
+	ServiceResult()
+{}
+
+DescribeCensResult::DescribeCensResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCensResult::~DescribeCensResult()
+{}
+
+void DescribeCensResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCensNode = value["Cens"]["Cen"];
+	for (auto valueCensCen : allCensNode)
+	{
+		Cen censObject;
+		if(!valueCensCen["Status"].isNull())
+			censObject.status = valueCensCen["Status"].asString();
+		if(!valueCensCen["CreationTime"].isNull())
+			censObject.creationTime = valueCensCen["CreationTime"].asString();
+		if(!valueCensCen["Ipv6Level"].isNull())
+			censObject.ipv6Level = valueCensCen["Ipv6Level"].asString();
+		if(!valueCensCen["Description"].isNull())
+			censObject.description = valueCensCen["Description"].asString();
+		if(!valueCensCen["CenId"].isNull())
+			censObject.cenId = valueCensCen["CenId"].asString();
+		if(!valueCensCen["ProtectionLevel"].isNull())
+			censObject.protectionLevel = valueCensCen["ProtectionLevel"].asString();
+		if(!valueCensCen["Name"].isNull())
+			censObject.name = valueCensCen["Name"].asString();
+		auto allTagsNode = valueCensCen["Tags"]["Tag"];
+		for (auto valueCensCenTagsTag : allTagsNode)
+		{
+			Cen::Tag tagsObject;
+			if(!valueCensCenTagsTag["Key"].isNull())
+				tagsObject.key = valueCensCenTagsTag["Key"].asString();
+			if(!valueCensCenTagsTag["Value"].isNull())
+				tagsObject.value = valueCensCenTagsTag["Value"].asString();
+			censObject.tags.push_back(tagsObject);
+		}
+		auto allPackageIdsNode = valueCensCen["PackageIds"]["PackageId"];
+		for (auto valueCensCenPackageIdsPackageId : allPackageIdsNode)
+		{
+			Cen::PackageId packageIdsObject;
+			if(!valueCensCenPackageIdsPackageId["PackageId"].isNull())
+				packageIdsObject.packageId = valueCensCenPackageIdsPackageId["PackageId"].asString();
+			censObject.packageIds.push_back(packageIdsObject);
+		}
+		cens_.push_back(censObject);
+	}
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeCensResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeCensResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeCensResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeCensResult::Cen> DescribeCensResult::getCens()const
+{
+	return cens_;
+}
+

ecd/src/model/DescribeClientEventsRequest.cc

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeClientEventsRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeClientEventsRequest;
+
+DescribeClientEventsRequest::DescribeClientEventsRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeClientEvents") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeClientEventsRequest::~DescribeClientEventsRequest() {}
+
+std::string DescribeClientEventsRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void DescribeClientEventsRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::vector<std::string> DescribeClientEventsRequest::getEventTypes() const {
+  return eventTypes_;
+}
+
+void DescribeClientEventsRequest::setEventTypes(const std::vector<std::string> &eventTypes) {
+  eventTypes_ = eventTypes;
+}
+
+std::string DescribeClientEventsRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeClientEventsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeClientEventsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeClientEventsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeClientEventsRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeClientEventsRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string DescribeClientEventsRequest::getEndUserId() const {
+  return endUserId_;
+}
+
+void DescribeClientEventsRequest::setEndUserId(const std::string &endUserId) {
+  endUserId_ = endUserId;
+  setParameter(std::string("EndUserId"), endUserId);
+}
+
+std::string DescribeClientEventsRequest::getDirectoryId() const {
+  return directoryId_;
+}
+
+void DescribeClientEventsRequest::setDirectoryId(const std::string &directoryId) {
+  directoryId_ = directoryId;
+  setParameter(std::string("DirectoryId"), directoryId);
+}
+
+std::string DescribeClientEventsRequest::getDesktopId() const {
+  return desktopId_;
+}
+
+void DescribeClientEventsRequest::setDesktopId(const std::string &desktopId) {
+  desktopId_ = desktopId;
+  setParameter(std::string("DesktopId"), desktopId);
+}
+
+std::string DescribeClientEventsRequest::getDesktopName() const {
+  return desktopName_;
+}
+
+void DescribeClientEventsRequest::setDesktopName(const std::string &desktopName) {
+  desktopName_ = desktopName;
+  setParameter(std::string("DesktopName"), desktopName);
+}
+
+std::string DescribeClientEventsRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeClientEventsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+std::string DescribeClientEventsRequest::getOfficeSiteName() const {
+  return officeSiteName_;
+}
+
+void DescribeClientEventsRequest::setOfficeSiteName(const std::string &officeSiteName) {
+  officeSiteName_ = officeSiteName;
+  setParameter(std::string("OfficeSiteName"), officeSiteName);
+}
+
+std::string DescribeClientEventsRequest::getDesktopIp() const {
+  return desktopIp_;
+}
+
+void DescribeClientEventsRequest::setDesktopIp(const std::string &desktopIp) {
+  desktopIp_ = desktopIp;
+  setParameter(std::string("DesktopIp"), desktopIp);
+}
+
+int DescribeClientEventsRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeClientEventsRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string DescribeClientEventsRequest::getEventType() const {
+  return eventType_;
+}
+
+void DescribeClientEventsRequest::setEventType(const std::string &eventType) {
+  eventType_ = eventType;
+  setParameter(std::string("EventType"), eventType);
+}
+

ecd/src/model/DescribeClientEventsResult.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeClientEventsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeClientEventsResult::DescribeClientEventsResult() :
+	ServiceResult()
+{}
+
+DescribeClientEventsResult::DescribeClientEventsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeClientEventsResult::~DescribeClientEventsResult()
+{}
+
+void DescribeClientEventsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allEventsNode = value["Events"]["Event"];
+	for (auto valueEventsEvent : allEventsNode)
+	{
+		Event eventsObject;
+		if(!valueEventsEvent["Status"].isNull())
+			eventsObject.status = valueEventsEvent["Status"].asString();
+		if(!valueEventsEvent["BytesReceived"].isNull())
+			eventsObject.bytesReceived = valueEventsEvent["BytesReceived"].asString();
+		if(!valueEventsEvent["DesktopIp"].isNull())
+			eventsObject.desktopIp = valueEventsEvent["DesktopIp"].asString();
+		if(!valueEventsEvent["EventTime"].isNull())
+			eventsObject.eventTime = valueEventsEvent["EventTime"].asString();
+		if(!valueEventsEvent["BytesSend"].isNull())
+			eventsObject.bytesSend = valueEventsEvent["BytesSend"].asString();
+		if(!valueEventsEvent["OfficeSiteId"].isNull())
+			eventsObject.officeSiteId = valueEventsEvent["OfficeSiteId"].asString();
+		if(!valueEventsEvent["AliUid"].isNull())
+			eventsObject.aliUid = valueEventsEvent["AliUid"].asString();
+		if(!valueEventsEvent["DesktopId"].isNull())
+			eventsObject.desktopId = valueEventsEvent["DesktopId"].asString();
+		if(!valueEventsEvent["RegionId"].isNull())
+			eventsObject.regionId = valueEventsEvent["RegionId"].asString();
+		if(!valueEventsEvent["EventId"].isNull())
+			eventsObject.eventId = valueEventsEvent["EventId"].asString();
+		if(!valueEventsEvent["DirectoryType"].isNull())
+			eventsObject.directoryType = valueEventsEvent["DirectoryType"].asString();
+		if(!valueEventsEvent["EventType"].isNull())
+			eventsObject.eventType = valueEventsEvent["EventType"].asString();
+		if(!valueEventsEvent["EndUserId"].isNull())
+			eventsObject.endUserId = valueEventsEvent["EndUserId"].asString();
+		if(!valueEventsEvent["ClientIp"].isNull())
+			eventsObject.clientIp = valueEventsEvent["ClientIp"].asString();
+		if(!valueEventsEvent["ClientOS"].isNull())
+			eventsObject.clientOS = valueEventsEvent["ClientOS"].asString();
+		if(!valueEventsEvent["OfficeSiteType"].isNull())
+			eventsObject.officeSiteType = valueEventsEvent["OfficeSiteType"].asString();
+		if(!valueEventsEvent["DirectoryId"].isNull())
+			eventsObject.directoryId = valueEventsEvent["DirectoryId"].asString();
+		if(!valueEventsEvent["ClientVersion"].isNull())
+			eventsObject.clientVersion = valueEventsEvent["ClientVersion"].asString();
+		if(!valueEventsEvent["OfficeSiteName"].isNull())
+			eventsObject.officeSiteName = valueEventsEvent["OfficeSiteName"].asString();
+		if(!valueEventsEvent["DesktopName"].isNull())
+			eventsObject.desktopName = valueEventsEvent["DesktopName"].asString();
+		if(!valueEventsEvent["DesktopGroupId"].isNull())
+			eventsObject.desktopGroupId = valueEventsEvent["DesktopGroupId"].asString();
+		if(!valueEventsEvent["DesktopGroupName"].isNull())
+			eventsObject.desktopGroupName = valueEventsEvent["DesktopGroupName"].asString();
+		events_.push_back(eventsObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::string DescribeClientEventsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<DescribeClientEventsResult::Event> DescribeClientEventsResult::getEvents()const
+{
+	return events_;
+}
+

ecd/src/model/DescribeCloudDrivePermissionsRequest.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/DescribeCloudDrivePermissionsRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeCloudDrivePermissionsRequest;
+
+DescribeCloudDrivePermissionsRequest::DescribeCloudDrivePermissionsRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeCloudDrivePermissions") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCloudDrivePermissionsRequest::~DescribeCloudDrivePermissionsRequest() {}
+
+std::string DescribeCloudDrivePermissionsRequest::getCdsId() const {
+  return cdsId_;
+}
+
+void DescribeCloudDrivePermissionsRequest::setCdsId(const std::string &cdsId) {
+  cdsId_ = cdsId;
+  setParameter(std::string("CdsId"), cdsId);
+}
+
+std::string DescribeCloudDrivePermissionsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeCloudDrivePermissionsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

ecd/src/model/DescribeCloudDrivePermissionsResult.cc

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

ecd/src/model/DescribeCustomizedListHeadersRequest.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/DescribeCustomizedListHeadersRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeCustomizedListHeadersRequest;
+
+DescribeCustomizedListHeadersRequest::DescribeCustomizedListHeadersRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeCustomizedListHeaders") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCustomizedListHeadersRequest::~DescribeCustomizedListHeadersRequest() {}
+
+std::string DescribeCustomizedListHeadersRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeCustomizedListHeadersRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeCustomizedListHeadersRequest::getLangType() const {
+  return langType_;
+}
+
+void DescribeCustomizedListHeadersRequest::setLangType(const std::string &langType) {
+  langType_ = langType;
+  setParameter(std::string("LangType"), langType);
+}
+
+std::string DescribeCustomizedListHeadersRequest::getListType() const {
+  return listType_;
+}
+
+void DescribeCustomizedListHeadersRequest::setListType(const std::string &listType) {
+  listType_ = listType;
+  setParameter(std::string("ListType"), listType);
+}
+

ecd/src/model/DescribeCustomizedListHeadersResult.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeCustomizedListHeadersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeCustomizedListHeadersResult::DescribeCustomizedListHeadersResult() :
+	ServiceResult()
+{}
+
+DescribeCustomizedListHeadersResult::DescribeCustomizedListHeadersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCustomizedListHeadersResult::~DescribeCustomizedListHeadersResult()
+{}
+
+void DescribeCustomizedListHeadersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allHeadersNode = value["Headers"]["Header"];
+	for (auto valueHeadersHeader : allHeadersNode)
+	{
+		Header headersObject;
+		if(!valueHeadersHeader["DisplayType"].isNull())
+			headersObject.displayType = valueHeadersHeader["DisplayType"].asString();
+		if(!valueHeadersHeader["HeaderKey"].isNull())
+			headersObject.headerKey = valueHeadersHeader["HeaderKey"].asString();
+		if(!valueHeadersHeader["HeaderName"].isNull())
+			headersObject.headerName = valueHeadersHeader["HeaderName"].asString();
+		headers_.push_back(headersObject);
+	}
+
+}
+
+std::vector<DescribeCustomizedListHeadersResult::Header> DescribeCustomizedListHeadersResult::getHeaders()const
+{
+	return headers_;
+}
+

ecd/src/model/DescribeDesktopGroupsRequest.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/DescribeDesktopGroupsRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeDesktopGroupsRequest;
+
+DescribeDesktopGroupsRequest::DescribeDesktopGroupsRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeDesktopGroups") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDesktopGroupsRequest::~DescribeDesktopGroupsRequest() {}
+
+std::string DescribeDesktopGroupsRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void DescribeDesktopGroupsRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::vector<std::string> DescribeDesktopGroupsRequest::getEndUserIds() const {
+  return endUserIds_;
+}
+
+void DescribeDesktopGroupsRequest::setEndUserIds(const std::vector<std::string> &endUserIds) {
+  endUserIds_ = endUserIds;
+}
+
+std::string DescribeDesktopGroupsRequest::getDesktopGroupName() const {
+  return desktopGroupName_;
+}
+
+void DescribeDesktopGroupsRequest::setDesktopGroupName(const std::string &desktopGroupName) {
+  desktopGroupName_ = desktopGroupName;
+  setParameter(std::string("DesktopGroupName"), desktopGroupName);
+}
+
+std::string DescribeDesktopGroupsRequest::getDesktopGroupId() const {
+  return desktopGroupId_;
+}
+
+void DescribeDesktopGroupsRequest::setDesktopGroupId(const std::string &desktopGroupId) {
+  desktopGroupId_ = desktopGroupId;
+  setParameter(std::string("DesktopGroupId"), desktopGroupId);
+}
+
+std::string DescribeDesktopGroupsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDesktopGroupsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDesktopGroupsRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeDesktopGroupsRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+int DescribeDesktopGroupsRequest::getPeriod() const {
+  return period_;
+}
+
+void DescribeDesktopGroupsRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
+}
+
+long DescribeDesktopGroupsRequest::getOwnType() const {
+  return ownType_;
+}
+
+void DescribeDesktopGroupsRequest::setOwnType(long ownType) {
+  ownType_ = ownType;
+  setParameter(std::string("OwnType"), std::to_string(ownType));
+}
+
+std::vector<std::string> DescribeDesktopGroupsRequest::getExcludedEndUserIds() const {
+  return excludedEndUserIds_;
+}
+
+void DescribeDesktopGroupsRequest::setExcludedEndUserIds(const std::vector<std::string> &excludedEndUserIds) {
+  excludedEndUserIds_ = excludedEndUserIds;
+}
+
+std::string DescribeDesktopGroupsRequest::getPeriodUnit() const {
+  return periodUnit_;
+}
+
+void DescribeDesktopGroupsRequest::setPeriodUnit(const std::string &periodUnit) {
+  periodUnit_ = periodUnit;
+  setParameter(std::string("PeriodUnit"), periodUnit);
+}
+
+int DescribeDesktopGroupsRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeDesktopGroupsRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string DescribeDesktopGroupsRequest::getPolicyGroupId() const {
+  return policyGroupId_;
+}
+
+void DescribeDesktopGroupsRequest::setPolicyGroupId(const std::string &policyGroupId) {
+  policyGroupId_ = policyGroupId;
+  setParameter(std::string("PolicyGroupId"), policyGroupId);
+}
+
+int DescribeDesktopGroupsRequest::getStatus() const {
+  return status_;
+}
+
+void DescribeDesktopGroupsRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

ecd/src/model/DescribeDesktopGroupsResult.cc

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDesktopGroupsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeDesktopGroupsResult::DescribeDesktopGroupsResult() :
+	ServiceResult()
+{}
+
+DescribeDesktopGroupsResult::DescribeDesktopGroupsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDesktopGroupsResult::~DescribeDesktopGroupsResult()
+{}
+
+void DescribeDesktopGroupsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDesktopGroupsNode = value["DesktopGroups"]["DesktopGroup"];
+	for (auto valueDesktopGroupsDesktopGroup : allDesktopGroupsNode)
+	{
+		DesktopGroup desktopGroupsObject;
+		if(!valueDesktopGroupsDesktopGroup["CreateTime"].isNull())
+			desktopGroupsObject.createTime = valueDesktopGroupsDesktopGroup["CreateTime"].asString();
+		if(!valueDesktopGroupsDesktopGroup["PayType"].isNull())
+			desktopGroupsObject.payType = valueDesktopGroupsDesktopGroup["PayType"].asString();
+		if(!valueDesktopGroupsDesktopGroup["PolicyGroupName"].isNull())
+			desktopGroupsObject.policyGroupName = valueDesktopGroupsDesktopGroup["PolicyGroupName"].asString();
+		if(!valueDesktopGroupsDesktopGroup["Creator"].isNull())
+			desktopGroupsObject.creator = valueDesktopGroupsDesktopGroup["Creator"].asString();
+		if(!valueDesktopGroupsDesktopGroup["MaxDesktopsCount"].isNull())
+			desktopGroupsObject.maxDesktopsCount = std::stoi(valueDesktopGroupsDesktopGroup["MaxDesktopsCount"].asString());
+		if(!valueDesktopGroupsDesktopGroup["SystemDiskSize"].isNull())
+			desktopGroupsObject.systemDiskSize = std::stoi(valueDesktopGroupsDesktopGroup["SystemDiskSize"].asString());
+		if(!valueDesktopGroupsDesktopGroup["PolicyGroupId"].isNull())
+			desktopGroupsObject.policyGroupId = valueDesktopGroupsDesktopGroup["PolicyGroupId"].asString();
+		if(!valueDesktopGroupsDesktopGroup["OwnBundleId"].isNull())
+			desktopGroupsObject.ownBundleId = valueDesktopGroupsDesktopGroup["OwnBundleId"].asString();
+		if(!valueDesktopGroupsDesktopGroup["GpuCount"].isNull())
+			desktopGroupsObject.gpuCount = std::stof(valueDesktopGroupsDesktopGroup["GpuCount"].asString());
+		if(!valueDesktopGroupsDesktopGroup["Memory"].isNull())
+			desktopGroupsObject.memory = std::stol(valueDesktopGroupsDesktopGroup["Memory"].asString());
+		if(!valueDesktopGroupsDesktopGroup["GpuSpec"].isNull())
+			desktopGroupsObject.gpuSpec = valueDesktopGroupsDesktopGroup["GpuSpec"].asString();
+		if(!valueDesktopGroupsDesktopGroup["DirectoryId"].isNull())
+			desktopGroupsObject.directoryId = valueDesktopGroupsDesktopGroup["DirectoryId"].asString();
+		if(!valueDesktopGroupsDesktopGroup["OwnBundleName"].isNull())
+			desktopGroupsObject.ownBundleName = valueDesktopGroupsDesktopGroup["OwnBundleName"].asString();
+		if(!valueDesktopGroupsDesktopGroup["DataDiskCategory"].isNull())
+			desktopGroupsObject.dataDiskCategory = valueDesktopGroupsDesktopGroup["DataDiskCategory"].asString();
+		if(!valueDesktopGroupsDesktopGroup["DesktopGroupName"].isNull())
+			desktopGroupsObject.desktopGroupName = valueDesktopGroupsDesktopGroup["DesktopGroupName"].asString();
+		if(!valueDesktopGroupsDesktopGroup["SystemDiskCategory"].isNull())
+			desktopGroupsObject.systemDiskCategory = valueDesktopGroupsDesktopGroup["SystemDiskCategory"].asString();
+		if(!valueDesktopGroupsDesktopGroup["OfficeSiteId"].isNull())
+			desktopGroupsObject.officeSiteId = valueDesktopGroupsDesktopGroup["OfficeSiteId"].asString();
+		if(!valueDesktopGroupsDesktopGroup["KeepDuration"].isNull())
+			desktopGroupsObject.keepDuration = std::stol(valueDesktopGroupsDesktopGroup["KeepDuration"].asString());
+		if(!valueDesktopGroupsDesktopGroup["MinDesktopsCount"].isNull())
+			desktopGroupsObject.minDesktopsCount = std::stoi(valueDesktopGroupsDesktopGroup["MinDesktopsCount"].asString());
+		if(!valueDesktopGroupsDesktopGroup["EndUserCount"].isNull())
+			desktopGroupsObject.endUserCount = std::stoi(valueDesktopGroupsDesktopGroup["EndUserCount"].asString());
+		if(!valueDesktopGroupsDesktopGroup["DataDiskSize"].isNull())
+			desktopGroupsObject.dataDiskSize = valueDesktopGroupsDesktopGroup["DataDiskSize"].asString();
+		if(!valueDesktopGroupsDesktopGroup["DesktopGroupId"].isNull())
+			desktopGroupsObject.desktopGroupId = valueDesktopGroupsDesktopGroup["DesktopGroupId"].asString();
+		if(!valueDesktopGroupsDesktopGroup["OfficeSiteName"].isNull())
+			desktopGroupsObject.officeSiteName = valueDesktopGroupsDesktopGroup["OfficeSiteName"].asString();
+		if(!valueDesktopGroupsDesktopGroup["DirectoryType"].isNull())
+			desktopGroupsObject.directoryType = valueDesktopGroupsDesktopGroup["DirectoryType"].asString();
+		if(!valueDesktopGroupsDesktopGroup["Cpu"].isNull())
+			desktopGroupsObject.cpu = std::stoi(valueDesktopGroupsDesktopGroup["Cpu"].asString());
+		if(!valueDesktopGroupsDesktopGroup["ExpiredTime"].isNull())
+			desktopGroupsObject.expiredTime = valueDesktopGroupsDesktopGroup["ExpiredTime"].asString();
+		if(!valueDesktopGroupsDesktopGroup["Comments"].isNull())
+			desktopGroupsObject.comments = valueDesktopGroupsDesktopGroup["Comments"].asString();
+		if(!valueDesktopGroupsDesktopGroup["OfficeSiteType"].isNull())
+			desktopGroupsObject.officeSiteType = valueDesktopGroupsDesktopGroup["OfficeSiteType"].asString();
+		if(!valueDesktopGroupsDesktopGroup["Status"].isNull())
+			desktopGroupsObject.status = std::stoi(valueDesktopGroupsDesktopGroup["Status"].asString());
+		if(!valueDesktopGroupsDesktopGroup["ResetType"].isNull())
+			desktopGroupsObject.resetType = std::stol(valueDesktopGroupsDesktopGroup["ResetType"].asString());
+		if(!valueDesktopGroupsDesktopGroup["LoadPolicy"].isNull())
+			desktopGroupsObject.loadPolicy = std::stol(valueDesktopGroupsDesktopGroup["LoadPolicy"].asString());
+		if(!valueDesktopGroupsDesktopGroup["BindAmount"].isNull())
+			desktopGroupsObject.bindAmount = std::stol(valueDesktopGroupsDesktopGroup["BindAmount"].asString());
+		if(!valueDesktopGroupsDesktopGroup["OwnType"].isNull())
+			desktopGroupsObject.ownType = std::stol(valueDesktopGroupsDesktopGroup["OwnType"].asString());
+		if(!valueDesktopGroupsDesktopGroup["ImageId"].isNull())
+			desktopGroupsObject.imageId = valueDesktopGroupsDesktopGroup["ImageId"].asString();
+		if(!valueDesktopGroupsDesktopGroup["VolumeEncryptionEnabled"].isNull())
+			desktopGroupsObject.volumeEncryptionEnabled = valueDesktopGroupsDesktopGroup["VolumeEncryptionEnabled"].asString() == "true";
+		if(!valueDesktopGroupsDesktopGroup["VolumeEncryptionKey"].isNull())
+			desktopGroupsObject.volumeEncryptionKey = valueDesktopGroupsDesktopGroup["VolumeEncryptionKey"].asString();
+		if(!valueDesktopGroupsDesktopGroup["RatioThreshold"].isNull())
+			desktopGroupsObject.ratioThreshold = std::stof(valueDesktopGroupsDesktopGroup["RatioThreshold"].asString());
+		if(!valueDesktopGroupsDesktopGroup["ConnectDuration"].isNull())
+			desktopGroupsObject.connectDuration = std::stol(valueDesktopGroupsDesktopGroup["ConnectDuration"].asString());
+		if(!valueDesktopGroupsDesktopGroup["IdleDisconnectDuration"].isNull())
+			desktopGroupsObject.idleDisconnectDuration = std::stol(valueDesktopGroupsDesktopGroup["IdleDisconnectDuration"].asString());
+		if(!valueDesktopGroupsDesktopGroup["Version"].isNull())
+			desktopGroupsObject.version = std::stoi(valueDesktopGroupsDesktopGroup["Version"].asString());
+		if(!valueDesktopGroupsDesktopGroup["StopDuration"].isNull())
+			desktopGroupsObject.stopDuration = std::stol(valueDesktopGroupsDesktopGroup["StopDuration"].asString());
+		desktopGroups_.push_back(desktopGroupsObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::vector<DescribeDesktopGroupsResult::DesktopGroup> DescribeDesktopGroupsResult::getDesktopGroups()const
+{
+	return desktopGroups_;
+}
+
+std::string DescribeDesktopGroupsResult::getNextToken()const
+{
+	return nextToken_;
+}
+

ecd/src/model/DescribeDesktopIdsByVulNamesRequest.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/DescribeDesktopIdsByVulNamesRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeDesktopIdsByVulNamesRequest;
+
+DescribeDesktopIdsByVulNamesRequest::DescribeDesktopIdsByVulNamesRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeDesktopIdsByVulNames") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDesktopIdsByVulNamesRequest::~DescribeDesktopIdsByVulNamesRequest() {}
+
+std::string DescribeDesktopIdsByVulNamesRequest::getOfficeSiteId() const {
+  return officeSiteId_;
+}
+
+void DescribeDesktopIdsByVulNamesRequest::setOfficeSiteId(const std::string &officeSiteId) {
+  officeSiteId_ = officeSiteId;
+  setParameter(std::string("OfficeSiteId"), officeSiteId);
+}
+
+std::string DescribeDesktopIdsByVulNamesRequest::getType() const {
+  return type_;
+}
+
+void DescribeDesktopIdsByVulNamesRequest::setType(const std::string &type) {
+  type_ = type;
+  setParameter(std::string("Type"), type);
+}
+
+std::vector<std::string> DescribeDesktopIdsByVulNamesRequest::getVulName() const {
+  return vulName_;
+}
+
+void DescribeDesktopIdsByVulNamesRequest::setVulName(const std::vector<std::string> &vulName) {
+  vulName_ = vulName;
+}
+
+std::string DescribeDesktopIdsByVulNamesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDesktopIdsByVulNamesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDesktopIdsByVulNamesRequest::getNecessity() const {
+  return necessity_;
+}
+
+void DescribeDesktopIdsByVulNamesRequest::setNecessity(const std::string &necessity) {
+  necessity_ = necessity;
+  setParameter(std::string("Necessity"), necessity);
+}
+

ecd/src/model/DescribeDesktopIdsByVulNamesResult.cc

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDesktopIdsByVulNamesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecd;
+using namespace AlibabaCloud::Ecd::Model;
+
+DescribeDesktopIdsByVulNamesResult::DescribeDesktopIdsByVulNamesResult() :
+	ServiceResult()
+{}
+
+DescribeDesktopIdsByVulNamesResult::DescribeDesktopIdsByVulNamesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDesktopIdsByVulNamesResult::~DescribeDesktopIdsByVulNamesResult()
+{}
+
+void DescribeDesktopIdsByVulNamesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDesktopItemsNode = value["DesktopItems"]["DesktopItem"];
+	for (auto valueDesktopItemsDesktopItem : allDesktopItemsNode)
+	{
+		DesktopItem desktopItemsObject;
+		if(!valueDesktopItemsDesktopItem["DesktopName"].isNull())
+			desktopItemsObject.desktopName = valueDesktopItemsDesktopItem["DesktopName"].asString();
+		if(!valueDesktopItemsDesktopItem["DesktopId"].isNull())
+			desktopItemsObject.desktopId = valueDesktopItemsDesktopItem["DesktopId"].asString();
+		desktopItems_.push_back(desktopItemsObject);
+	}
+
+}
+
+std::vector<DescribeDesktopIdsByVulNamesResult::DesktopItem> DescribeDesktopIdsByVulNamesResult::getDesktopItems()const
+{
+	return desktopItems_;
+}
+

ecd/src/model/DescribeDesktopTypesRequest.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/DescribeDesktopTypesRequest.h>
+
+using AlibabaCloud::Ecd::Model::DescribeDesktopTypesRequest;
+
+DescribeDesktopTypesRequest::DescribeDesktopTypesRequest()
+    : RpcServiceRequest("ecd", "2020-09-30", "DescribeDesktopTypes") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDesktopTypesRequest::~DescribeDesktopTypesRequest() {}
+
+std::string DescribeDesktopTypesRequest::getAppliedScope() const {
+  return appliedScope_;
+}
+
+void DescribeDesktopTypesRequest::setAppliedScope(const std::string &appliedScope) {
+  appliedScope_ = appliedScope;
+  setParameter(std::string("AppliedScope"), appliedScope);
+}
+
+int DescribeDesktopTypesRequest::getMemorySize() const {
+  return memorySize_;
+}
+
+void DescribeDesktopTypesRequest::setMemorySize(int memorySize) {
+  memorySize_ = memorySize;
+  setParameter(std::string("MemorySize"), std::to_string(memorySize));
+}
+
+float DescribeDesktopTypesRequest::getGpuCount() const {
+  return gpuCount_;
+}
+
+void DescribeDesktopTypesRequest::setGpuCount(float gpuCount) {
+  gpuCount_ = gpuCount;
+  setParameter(std::string("GpuCount"), std::to_string(gpuCount));
+}
+
+std::string DescribeDesktopTypesRequest::getInstanceTypeFamily() const {
+  return instanceTypeFamily_;
+}
+
+void DescribeDesktopTypesRequest::setInstanceTypeFamily(const std::string &instanceTypeFamily) {
+  instanceTypeFamily_ = instanceTypeFamily;
+  setParameter(std::string("InstanceTypeFamily"), instanceTypeFamily);
+}
+
+std::string DescribeDesktopTypesRequest::getDesktopTypeId() const {
+  return desktopTypeId_;
+}
+
+void DescribeDesktopTypesRequest::setDesktopTypeId(const std::string &desktopTypeId) {
+  desktopTypeId_ = desktopTypeId;
+  setParameter(std::string("DesktopTypeId"), desktopTypeId);
+}
+
+std::string DescribeDesktopTypesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDesktopTypesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDesktopTypesRequest::getDesktopIdForModify() const {
+  return desktopIdForModify_;
+}
+
+void DescribeDesktopTypesRequest::setDesktopIdForModify(const std::string &desktopIdForModify) {
+  desktopIdForModify_ = desktopIdForModify;
+  setParameter(std::string("DesktopIdForModify"), desktopIdForModify);
+}
+
+int DescribeDesktopTypesRequest::getCpuCount() const {
+  return cpuCount_;
+}
+
+void DescribeDesktopTypesRequest::setCpuCount(int cpuCount) {
+  cpuCount_ = cpuCount;
+  setParameter(std::string("CpuCount"), std::to_string(cpuCount));
+}
+
+std::string DescribeDesktopTypesRequest::getOrderType() const {
+  return orderType_;
+}
+
+void DescribeDesktopTypesRequest::setOrderType(const std::string &orderType) {
+  orderType_ = orderType;
+  setParameter(std::string("OrderType"), orderType);
+}
+