New API- GetDrdsDbRdsRelationInfo, which can get private RDS list under certain DB out of DRDS instance ID and DB name.

CHANGELOG

@@ -1,3 +1,47 @@
+2021-05-23 Version: 1.36.752
+- New API- GetDrdsDbRdsRelationInfo, which can get private RDS list under certain DB out of DRDS instance ID and DB name.
+
+2021-05-22 Version: 1.36.751
+- Aaaaa.
+
+2021-05-21 Version: 1.36.750
+- Supported DescribeLoadBalancers with DeleteProtection and so on.
+
+2021-05-21 Version: 1.36.749
+- Support StrictResourceProvision in ApplyNodes.
+
+2021-05-20 Version: 1.36.748
+- Upgrade mongodb sdk.
+
+2021-05-20 Version: 1.36.747
+- DescribeAvailableResource frequency.
+
+2021-05-19 Version: 1.36.746
+- Generated 2020-05-18 for `dataworks-public`.
+
+2021-05-19 Version: 1.36.745
+- Update API.
+
+2021-05-19 Version: 1.36.744
+- Publish multi language sdk.
+
+2021-05-18 Version: 1.36.743
+- Add IoT Studio SetStudioProjectCooperation API.
+- Add IoT Studio QueryStudioProjectList API.
+- Add IoT Studio QueryStudioAppList API.
+- Add IoT Studio QueryStudioAppPageListOpen API.
+- Add IoT Studio QueryStudioAppDomainListOpen API.
+- Add IoT Studio DeleteStudioAppDomainOpen API.
+- Add IoT Studio CreateStudioAppDomainOpen API.
+- Add IoT Studio GetStudioAppTokenOpen API.
+- Add IoT Studio SetupStudioAppAuthModeOpen API.
+- Add IoT Studio RefreshStudioAppTokenOpen API.
+- Add IoT Studio PublishStudioApp API.
+
+2021-05-18 Version: 1.36.742
+- Support MinCount for AddNodes.
+- Support HostNamePreffix and HostNameSuffix for ListNodes.
+
 2021-05-17 Version: 1.36.741
 - Add API ListQuotaReviewTasks.
 

VERSION

@@ -1 +1 @@
-1.36.741
+1.36.752

address-purification/CMakeLists.txt

@@ -29,18 +29,34 @@ set(address-purification_public_header_model
 	include/alibabacloud/address-purification/model/CorrectAddressResult.h
 	include/alibabacloud/address-purification/model/ExtractAddressRequest.h
 	include/alibabacloud/address-purification/model/ExtractAddressResult.h
+	include/alibabacloud/address-purification/model/ExtractExpressRequest.h
+	include/alibabacloud/address-purification/model/ExtractExpressResult.h
 	include/alibabacloud/address-purification/model/ExtractNameRequest.h
 	include/alibabacloud/address-purification/model/ExtractNameResult.h
 	include/alibabacloud/address-purification/model/ExtractPhoneRequest.h
 	include/alibabacloud/address-purification/model/ExtractPhoneResult.h
+	include/alibabacloud/address-purification/model/GetAddressBlockMappingRequest.h
+	include/alibabacloud/address-purification/model/GetAddressBlockMappingResult.h
 	include/alibabacloud/address-purification/model/GetAddressDivisionCodeRequest.h
 	include/alibabacloud/address-purification/model/GetAddressDivisionCodeResult.h
+	include/alibabacloud/address-purification/model/GetAddressEvaluateRequest.h
+	include/alibabacloud/address-purification/model/GetAddressEvaluateResult.h
+	include/alibabacloud/address-purification/model/GetAddressGeocodeRequest.h
+	include/alibabacloud/address-purification/model/GetAddressGeocodeResult.h
+	include/alibabacloud/address-purification/model/GetAddressSearchRequest.h
+	include/alibabacloud/address-purification/model/GetAddressSearchResult.h
 	include/alibabacloud/address-purification/model/GetAddressSimilarityRequest.h
 	include/alibabacloud/address-purification/model/GetAddressSimilarityResult.h
+	include/alibabacloud/address-purification/model/GetInputSearchRequest.h
+	include/alibabacloud/address-purification/model/GetInputSearchResult.h
 	include/alibabacloud/address-purification/model/GetZipcodeRequest.h
 	include/alibabacloud/address-purification/model/GetZipcodeResult.h
+	include/alibabacloud/address-purification/model/PredictPOIRequest.h
+	include/alibabacloud/address-purification/model/PredictPOIResult.h
 	include/alibabacloud/address-purification/model/StructureAddressRequest.h
 	include/alibabacloud/address-purification/model/StructureAddressResult.h
+	include/alibabacloud/address-purification/model/TransferCoordRequest.h
+	include/alibabacloud/address-purification/model/TransferCoordResult.h
 	include/alibabacloud/address-purification/model/UpdateProjectRequest.h
 	include/alibabacloud/address-purification/model/UpdateProjectResult.h )
 
@@ -54,18 +70,34 @@ set(address-purification_src
 	src/model/CorrectAddressResult.cc
 	src/model/ExtractAddressRequest.cc
 	src/model/ExtractAddressResult.cc
+	src/model/ExtractExpressRequest.cc
+	src/model/ExtractExpressResult.cc
 	src/model/ExtractNameRequest.cc
 	src/model/ExtractNameResult.cc
 	src/model/ExtractPhoneRequest.cc
 	src/model/ExtractPhoneResult.cc
+	src/model/GetAddressBlockMappingRequest.cc
+	src/model/GetAddressBlockMappingResult.cc
 	src/model/GetAddressDivisionCodeRequest.cc
 	src/model/GetAddressDivisionCodeResult.cc
+	src/model/GetAddressEvaluateRequest.cc
+	src/model/GetAddressEvaluateResult.cc
+	src/model/GetAddressGeocodeRequest.cc
+	src/model/GetAddressGeocodeResult.cc
+	src/model/GetAddressSearchRequest.cc
+	src/model/GetAddressSearchResult.cc
 	src/model/GetAddressSimilarityRequest.cc
 	src/model/GetAddressSimilarityResult.cc
+	src/model/GetInputSearchRequest.cc
+	src/model/GetInputSearchResult.cc
 	src/model/GetZipcodeRequest.cc
 	src/model/GetZipcodeResult.cc
+	src/model/PredictPOIRequest.cc
+	src/model/PredictPOIResult.cc
 	src/model/StructureAddressRequest.cc
 	src/model/StructureAddressResult.cc
+	src/model/TransferCoordRequest.cc
+	src/model/TransferCoordResult.cc
 	src/model/UpdateProjectRequest.cc
 	src/model/UpdateProjectResult.cc )
 

address-purification/include/alibabacloud/address-purification/Address_purificationClient.h

@@ -30,18 +30,34 @@
 #include "model/CorrectAddressResult.h"
 #include "model/ExtractAddressRequest.h"
 #include "model/ExtractAddressResult.h"
+#include "model/ExtractExpressRequest.h"
+#include "model/ExtractExpressResult.h"
 #include "model/ExtractNameRequest.h"
 #include "model/ExtractNameResult.h"
 #include "model/ExtractPhoneRequest.h"
 #include "model/ExtractPhoneResult.h"
+#include "model/GetAddressBlockMappingRequest.h"
+#include "model/GetAddressBlockMappingResult.h"
 #include "model/GetAddressDivisionCodeRequest.h"
 #include "model/GetAddressDivisionCodeResult.h"
+#include "model/GetAddressEvaluateRequest.h"
+#include "model/GetAddressEvaluateResult.h"
+#include "model/GetAddressGeocodeRequest.h"
+#include "model/GetAddressGeocodeResult.h"
+#include "model/GetAddressSearchRequest.h"
+#include "model/GetAddressSearchResult.h"
 #include "model/GetAddressSimilarityRequest.h"
 #include "model/GetAddressSimilarityResult.h"
+#include "model/GetInputSearchRequest.h"
+#include "model/GetInputSearchResult.h"
 #include "model/GetZipcodeRequest.h"
 #include "model/GetZipcodeResult.h"
+#include "model/PredictPOIRequest.h"
+#include "model/PredictPOIResult.h"
 #include "model/StructureAddressRequest.h"
 #include "model/StructureAddressResult.h"
+#include "model/TransferCoordRequest.h"
+#include "model/TransferCoordResult.h"
 #include "model/UpdateProjectRequest.h"
 #include "model/UpdateProjectResult.h"
 
@@ -65,24 +81,48 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ExtractAddressResult> ExtractAddressOutcome;
 			typedef std::future<ExtractAddressOutcome> ExtractAddressOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::ExtractAddressRequest&, const ExtractAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractAddressAsyncHandler;
+			typedef Outcome<Error, Model::ExtractExpressResult> ExtractExpressOutcome;
+			typedef std::future<ExtractExpressOutcome> ExtractExpressOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::ExtractExpressRequest&, const ExtractExpressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractExpressAsyncHandler;
 			typedef Outcome<Error, Model::ExtractNameResult> ExtractNameOutcome;
 			typedef std::future<ExtractNameOutcome> ExtractNameOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::ExtractNameRequest&, const ExtractNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractNameAsyncHandler;
 			typedef Outcome<Error, Model::ExtractPhoneResult> ExtractPhoneOutcome;
 			typedef std::future<ExtractPhoneOutcome> ExtractPhoneOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::ExtractPhoneRequest&, const ExtractPhoneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractPhoneAsyncHandler;
+			typedef Outcome<Error, Model::GetAddressBlockMappingResult> GetAddressBlockMappingOutcome;
+			typedef std::future<GetAddressBlockMappingOutcome> GetAddressBlockMappingOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressBlockMappingRequest&, const GetAddressBlockMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressBlockMappingAsyncHandler;
 			typedef Outcome<Error, Model::GetAddressDivisionCodeResult> GetAddressDivisionCodeOutcome;
 			typedef std::future<GetAddressDivisionCodeOutcome> GetAddressDivisionCodeOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressDivisionCodeRequest&, const GetAddressDivisionCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressDivisionCodeAsyncHandler;
+			typedef Outcome<Error, Model::GetAddressEvaluateResult> GetAddressEvaluateOutcome;
+			typedef std::future<GetAddressEvaluateOutcome> GetAddressEvaluateOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressEvaluateRequest&, const GetAddressEvaluateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressEvaluateAsyncHandler;
+			typedef Outcome<Error, Model::GetAddressGeocodeResult> GetAddressGeocodeOutcome;
+			typedef std::future<GetAddressGeocodeOutcome> GetAddressGeocodeOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressGeocodeRequest&, const GetAddressGeocodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressGeocodeAsyncHandler;
+			typedef Outcome<Error, Model::GetAddressSearchResult> GetAddressSearchOutcome;
+			typedef std::future<GetAddressSearchOutcome> GetAddressSearchOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressSearchRequest&, const GetAddressSearchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressSearchAsyncHandler;
 			typedef Outcome<Error, Model::GetAddressSimilarityResult> GetAddressSimilarityOutcome;
 			typedef std::future<GetAddressSimilarityOutcome> GetAddressSimilarityOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressSimilarityRequest&, const GetAddressSimilarityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressSimilarityAsyncHandler;
+			typedef Outcome<Error, Model::GetInputSearchResult> GetInputSearchOutcome;
+			typedef std::future<GetInputSearchOutcome> GetInputSearchOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetInputSearchRequest&, const GetInputSearchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInputSearchAsyncHandler;
 			typedef Outcome<Error, Model::GetZipcodeResult> GetZipcodeOutcome;
 			typedef std::future<GetZipcodeOutcome> GetZipcodeOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::GetZipcodeRequest&, const GetZipcodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetZipcodeAsyncHandler;
+			typedef Outcome<Error, Model::PredictPOIResult> PredictPOIOutcome;
+			typedef std::future<PredictPOIOutcome> PredictPOIOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::PredictPOIRequest&, const PredictPOIOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PredictPOIAsyncHandler;
 			typedef Outcome<Error, Model::StructureAddressResult> StructureAddressOutcome;
 			typedef std::future<StructureAddressOutcome> StructureAddressOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::StructureAddressRequest&, const StructureAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StructureAddressAsyncHandler;
+			typedef Outcome<Error, Model::TransferCoordResult> TransferCoordOutcome;
+			typedef std::future<TransferCoordOutcome> TransferCoordOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::TransferCoordRequest&, const TransferCoordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TransferCoordAsyncHandler;
 			typedef Outcome<Error, Model::UpdateProjectResult> UpdateProjectOutcome;
 			typedef std::future<UpdateProjectOutcome> UpdateProjectOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::UpdateProjectRequest&, const UpdateProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateProjectAsyncHandler;
@@ -103,24 +143,48 @@ namespace AlibabaCloud
 			ExtractAddressOutcome extractAddress(const Model::ExtractAddressRequest &request)const;
 			void extractAddressAsync(const Model::ExtractAddressRequest& request, const ExtractAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExtractAddressOutcomeCallable extractAddressCallable(const Model::ExtractAddressRequest& request) const;
+			ExtractExpressOutcome extractExpress(const Model::ExtractExpressRequest &request)const;
+			void extractExpressAsync(const Model::ExtractExpressRequest& request, const ExtractExpressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExtractExpressOutcomeCallable extractExpressCallable(const Model::ExtractExpressRequest& request) const;
 			ExtractNameOutcome extractName(const Model::ExtractNameRequest &request)const;
 			void extractNameAsync(const Model::ExtractNameRequest& request, const ExtractNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExtractNameOutcomeCallable extractNameCallable(const Model::ExtractNameRequest& request) const;
 			ExtractPhoneOutcome extractPhone(const Model::ExtractPhoneRequest &request)const;
 			void extractPhoneAsync(const Model::ExtractPhoneRequest& request, const ExtractPhoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExtractPhoneOutcomeCallable extractPhoneCallable(const Model::ExtractPhoneRequest& request) const;
+			GetAddressBlockMappingOutcome getAddressBlockMapping(const Model::GetAddressBlockMappingRequest &request)const;
+			void getAddressBlockMappingAsync(const Model::GetAddressBlockMappingRequest& request, const GetAddressBlockMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAddressBlockMappingOutcomeCallable getAddressBlockMappingCallable(const Model::GetAddressBlockMappingRequest& request) const;
 			GetAddressDivisionCodeOutcome getAddressDivisionCode(const Model::GetAddressDivisionCodeRequest &request)const;
 			void getAddressDivisionCodeAsync(const Model::GetAddressDivisionCodeRequest& request, const GetAddressDivisionCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAddressDivisionCodeOutcomeCallable getAddressDivisionCodeCallable(const Model::GetAddressDivisionCodeRequest& request) const;
+			GetAddressEvaluateOutcome getAddressEvaluate(const Model::GetAddressEvaluateRequest &request)const;
+			void getAddressEvaluateAsync(const Model::GetAddressEvaluateRequest& request, const GetAddressEvaluateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAddressEvaluateOutcomeCallable getAddressEvaluateCallable(const Model::GetAddressEvaluateRequest& request) const;
+			GetAddressGeocodeOutcome getAddressGeocode(const Model::GetAddressGeocodeRequest &request)const;
+			void getAddressGeocodeAsync(const Model::GetAddressGeocodeRequest& request, const GetAddressGeocodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAddressGeocodeOutcomeCallable getAddressGeocodeCallable(const Model::GetAddressGeocodeRequest& request) const;
+			GetAddressSearchOutcome getAddressSearch(const Model::GetAddressSearchRequest &request)const;
+			void getAddressSearchAsync(const Model::GetAddressSearchRequest& request, const GetAddressSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAddressSearchOutcomeCallable getAddressSearchCallable(const Model::GetAddressSearchRequest& request) const;
 			GetAddressSimilarityOutcome getAddressSimilarity(const Model::GetAddressSimilarityRequest &request)const;
 			void getAddressSimilarityAsync(const Model::GetAddressSimilarityRequest& request, const GetAddressSimilarityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAddressSimilarityOutcomeCallable getAddressSimilarityCallable(const Model::GetAddressSimilarityRequest& request) const;
+			GetInputSearchOutcome getInputSearch(const Model::GetInputSearchRequest &request)const;
+			void getInputSearchAsync(const Model::GetInputSearchRequest& request, const GetInputSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetInputSearchOutcomeCallable getInputSearchCallable(const Model::GetInputSearchRequest& request) const;
 			GetZipcodeOutcome getZipcode(const Model::GetZipcodeRequest &request)const;
 			void getZipcodeAsync(const Model::GetZipcodeRequest& request, const GetZipcodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetZipcodeOutcomeCallable getZipcodeCallable(const Model::GetZipcodeRequest& request) const;
+			PredictPOIOutcome predictPOI(const Model::PredictPOIRequest &request)const;
+			void predictPOIAsync(const Model::PredictPOIRequest& request, const PredictPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PredictPOIOutcomeCallable predictPOICallable(const Model::PredictPOIRequest& request) const;
 			StructureAddressOutcome structureAddress(const Model::StructureAddressRequest &request)const;
 			void structureAddressAsync(const Model::StructureAddressRequest& request, const StructureAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StructureAddressOutcomeCallable structureAddressCallable(const Model::StructureAddressRequest& request) const;
+			TransferCoordOutcome transferCoord(const Model::TransferCoordRequest &request)const;
+			void transferCoordAsync(const Model::TransferCoordRequest& request, const TransferCoordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TransferCoordOutcomeCallable transferCoordCallable(const Model::TransferCoordRequest& request) const;
 			UpdateProjectOutcome updateProject(const Model::UpdateProjectRequest &request)const;
 			void updateProjectAsync(const Model::UpdateProjectRequest& request, const UpdateProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateProjectOutcomeCallable updateProjectCallable(const Model::UpdateProjectRequest& request) const;

address-purification/include/alibabacloud/address-purification/model/ExtractExpressRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractExpressRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExtractExpressRequest();
+				~ExtractExpressRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/ExtractExpressResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractExpressResult : public ServiceResult
+			{
+			public:
+
+
+				ExtractExpressResult();
+				explicit ExtractExpressResult(const std::string &payload);
+				~ExtractExpressResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSRESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressBlockMappingRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressBlockMappingRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressBlockMappingRequest();
+				~GetAddressBlockMappingRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressBlockMappingResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressBlockMappingResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressBlockMappingResult();
+				explicit GetAddressBlockMappingResult(const std::string &payload);
+				~GetAddressBlockMappingResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGRESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressEvaluateRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATEREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressEvaluateRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressEvaluateRequest();
+				~GetAddressEvaluateRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATEREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressEvaluateResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATERESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressEvaluateResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressEvaluateResult();
+				explicit GetAddressEvaluateResult(const std::string &payload);
+				~GetAddressEvaluateResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATERESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressGeocodeRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODEREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressGeocodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressGeocodeRequest();
+				~GetAddressGeocodeRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODEREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressGeocodeResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressGeocodeResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressGeocodeResult();
+				explicit GetAddressGeocodeResult(const std::string &payload);
+				~GetAddressGeocodeResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressSearchRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressSearchRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressSearchRequest();
+				~GetAddressSearchRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressSearchResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressSearchResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressSearchResult();
+				explicit GetAddressSearchResult(const std::string &payload);
+				~GetAddressSearchResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHRESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetInputSearchRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetInputSearchRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetInputSearchRequest();
+				~GetInputSearchRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetInputSearchResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetInputSearchResult : public ServiceResult
+			{
+			public:
+
+
+				GetInputSearchResult();
+				explicit GetInputSearchResult(const std::string &payload);
+				~GetInputSearchResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHRESULT_H_

address-purification/include/alibabacloud/address-purification/model/PredictPOIRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT PredictPOIRequest : public RpcServiceRequest
+			{
+
+			public:
+				PredictPOIRequest();
+				~PredictPOIRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/PredictPOIResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT PredictPOIResult : public ServiceResult
+			{
+			public:
+
+
+				PredictPOIResult();
+				explicit PredictPOIResult(const std::string &payload);
+				~PredictPOIResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIRESULT_H_

address-purification/include/alibabacloud/address-purification/model/TransferCoordRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT TransferCoordRequest : public RpcServiceRequest
+			{
+
+			public:
+				TransferCoordRequest();
+				~TransferCoordRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getSrcCoord()const;
+				void setSrcCoord(const std::string& srcCoord);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getText()const;
+				void setText(const std::string& text);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+
+            private:
+				std::string defaultProvince_;
+				std::string srcCoord_;
+				std::string defaultCity_;
+				std::string text_;
+				std::string serviceCode_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/TransferCoordResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT TransferCoordResult : public ServiceResult
+			{
+			public:
+
+
+				TransferCoordResult();
+				explicit TransferCoordResult(const std::string &payload);
+				~TransferCoordResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDRESULT_H_

address-purification/src/Address-purificationClient.cc

@@ -195,6 +195,42 @@ Address_purificationClient::ExtractAddressOutcomeCallable Address_purificationCl
 	return task->get_future();
 }
 
+Address_purificationClient::ExtractExpressOutcome Address_purificationClient::extractExpress(const ExtractExpressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExtractExpressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExtractExpressOutcome(ExtractExpressResult(outcome.result()));
+	else
+		return ExtractExpressOutcome(outcome.error());
+}
+
+void Address_purificationClient::extractExpressAsync(const ExtractExpressRequest& request, const ExtractExpressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, extractExpress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::ExtractExpressOutcomeCallable Address_purificationClient::extractExpressCallable(const ExtractExpressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExtractExpressOutcome()>>(
+			[this, request]()
+			{
+			return this->extractExpress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::ExtractNameOutcome Address_purificationClient::extractName(const ExtractNameRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,42 @@ Address_purificationClient::ExtractPhoneOutcomeCallable Address_purificationClie
 	return task->get_future();
 }
 
+Address_purificationClient::GetAddressBlockMappingOutcome Address_purificationClient::getAddressBlockMapping(const GetAddressBlockMappingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressBlockMappingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressBlockMappingOutcome(GetAddressBlockMappingResult(outcome.result()));
+	else
+		return GetAddressBlockMappingOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressBlockMappingAsync(const GetAddressBlockMappingRequest& request, const GetAddressBlockMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressBlockMapping(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressBlockMappingOutcomeCallable Address_purificationClient::getAddressBlockMappingCallable(const GetAddressBlockMappingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressBlockMappingOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressBlockMapping(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::GetAddressDivisionCodeOutcome Address_purificationClient::getAddressDivisionCode(const GetAddressDivisionCodeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +375,114 @@ Address_purificationClient::GetAddressDivisionCodeOutcomeCallable Address_purifi
 	return task->get_future();
 }
 
+Address_purificationClient::GetAddressEvaluateOutcome Address_purificationClient::getAddressEvaluate(const GetAddressEvaluateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressEvaluateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressEvaluateOutcome(GetAddressEvaluateResult(outcome.result()));
+	else
+		return GetAddressEvaluateOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressEvaluateAsync(const GetAddressEvaluateRequest& request, const GetAddressEvaluateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressEvaluate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressEvaluateOutcomeCallable Address_purificationClient::getAddressEvaluateCallable(const GetAddressEvaluateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressEvaluateOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressEvaluate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::GetAddressGeocodeOutcome Address_purificationClient::getAddressGeocode(const GetAddressGeocodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressGeocodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressGeocodeOutcome(GetAddressGeocodeResult(outcome.result()));
+	else
+		return GetAddressGeocodeOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressGeocodeAsync(const GetAddressGeocodeRequest& request, const GetAddressGeocodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressGeocode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressGeocodeOutcomeCallable Address_purificationClient::getAddressGeocodeCallable(const GetAddressGeocodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressGeocodeOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressGeocode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::GetAddressSearchOutcome Address_purificationClient::getAddressSearch(const GetAddressSearchRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressSearchOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressSearchOutcome(GetAddressSearchResult(outcome.result()));
+	else
+		return GetAddressSearchOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressSearchAsync(const GetAddressSearchRequest& request, const GetAddressSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressSearch(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressSearchOutcomeCallable Address_purificationClient::getAddressSearchCallable(const GetAddressSearchRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressSearchOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressSearch(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::GetAddressSimilarityOutcome Address_purificationClient::getAddressSimilarity(const GetAddressSimilarityRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +519,42 @@ Address_purificationClient::GetAddressSimilarityOutcomeCallable Address_purifica
 	return task->get_future();
 }
 
+Address_purificationClient::GetInputSearchOutcome Address_purificationClient::getInputSearch(const GetInputSearchRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetInputSearchOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetInputSearchOutcome(GetInputSearchResult(outcome.result()));
+	else
+		return GetInputSearchOutcome(outcome.error());
+}
+
+void Address_purificationClient::getInputSearchAsync(const GetInputSearchRequest& request, const GetInputSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getInputSearch(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetInputSearchOutcomeCallable Address_purificationClient::getInputSearchCallable(const GetInputSearchRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetInputSearchOutcome()>>(
+			[this, request]()
+			{
+			return this->getInputSearch(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::GetZipcodeOutcome Address_purificationClient::getZipcode(const GetZipcodeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -375,6 +591,42 @@ Address_purificationClient::GetZipcodeOutcomeCallable Address_purificationClient
 	return task->get_future();
 }
 
+Address_purificationClient::PredictPOIOutcome Address_purificationClient::predictPOI(const PredictPOIRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PredictPOIOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PredictPOIOutcome(PredictPOIResult(outcome.result()));
+	else
+		return PredictPOIOutcome(outcome.error());
+}
+
+void Address_purificationClient::predictPOIAsync(const PredictPOIRequest& request, const PredictPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, predictPOI(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::PredictPOIOutcomeCallable Address_purificationClient::predictPOICallable(const PredictPOIRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PredictPOIOutcome()>>(
+			[this, request]()
+			{
+			return this->predictPOI(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::StructureAddressOutcome Address_purificationClient::structureAddress(const StructureAddressRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -411,6 +663,42 @@ Address_purificationClient::StructureAddressOutcomeCallable Address_purification
 	return task->get_future();
 }
 
+Address_purificationClient::TransferCoordOutcome Address_purificationClient::transferCoord(const TransferCoordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TransferCoordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TransferCoordOutcome(TransferCoordResult(outcome.result()));
+	else
+		return TransferCoordOutcome(outcome.error());
+}
+
+void Address_purificationClient::transferCoordAsync(const TransferCoordRequest& request, const TransferCoordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, transferCoord(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::TransferCoordOutcomeCallable Address_purificationClient::transferCoordCallable(const TransferCoordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TransferCoordOutcome()>>(
+			[this, request]()
+			{
+			return this->transferCoord(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::UpdateProjectOutcome Address_purificationClient::updateProject(const UpdateProjectRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

address-purification/src/model/ExtractExpressRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/ExtractExpressRequest.h>
+
+using AlibabaCloud::Address_purification::Model::ExtractExpressRequest;
+
+ExtractExpressRequest::ExtractExpressRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "ExtractExpress")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ExtractExpressRequest::~ExtractExpressRequest()
+{}
+
+std::string ExtractExpressRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void ExtractExpressRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string ExtractExpressRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void ExtractExpressRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string ExtractExpressRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void ExtractExpressRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string ExtractExpressRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void ExtractExpressRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string ExtractExpressRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void ExtractExpressRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string ExtractExpressRequest::getText()const
+{
+	return text_;
+}
+
+void ExtractExpressRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

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

address-purification/src/model/GetAddressBlockMappingRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetAddressBlockMappingRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetAddressBlockMappingRequest;
+
+GetAddressBlockMappingRequest::GetAddressBlockMappingRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetAddressBlockMapping")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetAddressBlockMappingRequest::~GetAddressBlockMappingRequest()
+{}
+
+std::string GetAddressBlockMappingRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetAddressBlockMappingRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetAddressBlockMappingRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetAddressBlockMappingRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetAddressBlockMappingRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetAddressBlockMappingRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetAddressBlockMappingRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetAddressBlockMappingRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetAddressBlockMappingRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetAddressBlockMappingRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetAddressBlockMappingRequest::getText()const
+{
+	return text_;
+}
+
+void GetAddressBlockMappingRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

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

address-purification/src/model/GetAddressEvaluateRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetAddressEvaluateRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetAddressEvaluateRequest;
+
+GetAddressEvaluateRequest::GetAddressEvaluateRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetAddressEvaluate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetAddressEvaluateRequest::~GetAddressEvaluateRequest()
+{}
+
+std::string GetAddressEvaluateRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetAddressEvaluateRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetAddressEvaluateRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetAddressEvaluateRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetAddressEvaluateRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetAddressEvaluateRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetAddressEvaluateRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetAddressEvaluateRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetAddressEvaluateRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetAddressEvaluateRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetAddressEvaluateRequest::getText()const
+{
+	return text_;
+}
+
+void GetAddressEvaluateRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

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

address-purification/src/model/GetAddressGeocodeRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetAddressGeocodeRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetAddressGeocodeRequest;
+
+GetAddressGeocodeRequest::GetAddressGeocodeRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetAddressGeocode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetAddressGeocodeRequest::~GetAddressGeocodeRequest()
+{}
+
+std::string GetAddressGeocodeRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetAddressGeocodeRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetAddressGeocodeRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetAddressGeocodeRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetAddressGeocodeRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetAddressGeocodeRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetAddressGeocodeRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetAddressGeocodeRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetAddressGeocodeRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetAddressGeocodeRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetAddressGeocodeRequest::getText()const
+{
+	return text_;
+}
+
+void GetAddressGeocodeRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

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

address-purification/src/model/GetAddressSearchRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetAddressSearchRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetAddressSearchRequest;
+
+GetAddressSearchRequest::GetAddressSearchRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetAddressSearch")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetAddressSearchRequest::~GetAddressSearchRequest()
+{}
+
+std::string GetAddressSearchRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetAddressSearchRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetAddressSearchRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetAddressSearchRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetAddressSearchRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetAddressSearchRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetAddressSearchRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetAddressSearchRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetAddressSearchRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetAddressSearchRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetAddressSearchRequest::getText()const
+{
+	return text_;
+}
+
+void GetAddressSearchRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

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

address-purification/src/model/GetInputSearchRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetInputSearchRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetInputSearchRequest;
+
+GetInputSearchRequest::GetInputSearchRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetInputSearch")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetInputSearchRequest::~GetInputSearchRequest()
+{}
+
+std::string GetInputSearchRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetInputSearchRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetInputSearchRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetInputSearchRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetInputSearchRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetInputSearchRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetInputSearchRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetInputSearchRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetInputSearchRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetInputSearchRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetInputSearchRequest::getText()const
+{
+	return text_;
+}
+
+void GetInputSearchRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

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

address-purification/src/model/PredictPOIRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/PredictPOIRequest.h>
+
+using AlibabaCloud::Address_purification::Model::PredictPOIRequest;
+
+PredictPOIRequest::PredictPOIRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "PredictPOI")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PredictPOIRequest::~PredictPOIRequest()
+{}
+
+std::string PredictPOIRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void PredictPOIRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string PredictPOIRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void PredictPOIRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string PredictPOIRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void PredictPOIRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string PredictPOIRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void PredictPOIRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string PredictPOIRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void PredictPOIRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string PredictPOIRequest::getText()const
+{
+	return text_;
+}
+
+void PredictPOIRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

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

address-purification/src/model/TransferCoordRequest.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/address-purification/model/TransferCoordRequest.h>
+
+using AlibabaCloud::Address_purification::Model::TransferCoordRequest;
+
+TransferCoordRequest::TransferCoordRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "TransferCoord")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+TransferCoordRequest::~TransferCoordRequest()
+{}
+
+std::string TransferCoordRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void TransferCoordRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string TransferCoordRequest::getSrcCoord()const
+{
+	return srcCoord_;
+}
+
+void TransferCoordRequest::setSrcCoord(const std::string& srcCoord)
+{
+	srcCoord_ = srcCoord;
+	setBodyParameter("SrcCoord", srcCoord);
+}
+
+std::string TransferCoordRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void TransferCoordRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string TransferCoordRequest::getText()const
+{
+	return text_;
+}
+
+void TransferCoordRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+
+std::string TransferCoordRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void TransferCoordRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string TransferCoordRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void TransferCoordRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string TransferCoordRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void TransferCoordRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+

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

dataworks-public/CMakeLists.txt

@@ -395,6 +395,10 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/UpdateMetaTableResult.h
 	include/alibabacloud/dataworks-public/model/UpdateMetaTableIntroWikiRequest.h
 	include/alibabacloud/dataworks-public/model/UpdateMetaTableIntroWikiResult.h
+	include/alibabacloud/dataworks-public/model/UpdateNodeOwnerRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateNodeOwnerResult.h
+	include/alibabacloud/dataworks-public/model/UpdateNodeRunModeRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateNodeRunModeResult.h
 	include/alibabacloud/dataworks-public/model/UpdateQualityFollowerRequest.h
 	include/alibabacloud/dataworks-public/model/UpdateQualityFollowerResult.h
 	include/alibabacloud/dataworks-public/model/UpdateQualityRuleRequest.h
@@ -790,6 +794,10 @@ set(dataworks-public_src
 	src/model/UpdateMetaTableResult.cc
 	src/model/UpdateMetaTableIntroWikiRequest.cc
 	src/model/UpdateMetaTableIntroWikiResult.cc
+	src/model/UpdateNodeOwnerRequest.cc
+	src/model/UpdateNodeOwnerResult.cc
+	src/model/UpdateNodeRunModeRequest.cc
+	src/model/UpdateNodeRunModeResult.cc
 	src/model/UpdateQualityFollowerRequest.cc
 	src/model/UpdateQualityFollowerResult.cc
 	src/model/UpdateQualityRuleRequest.cc

dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h

@@ -396,6 +396,10 @@
 #include "model/UpdateMetaTableResult.h"
 #include "model/UpdateMetaTableIntroWikiRequest.h"
 #include "model/UpdateMetaTableIntroWikiResult.h"
+#include "model/UpdateNodeOwnerRequest.h"
+#include "model/UpdateNodeOwnerResult.h"
+#include "model/UpdateNodeRunModeRequest.h"
+#include "model/UpdateNodeRunModeResult.h"
 #include "model/UpdateQualityFollowerRequest.h"
 #include "model/UpdateQualityFollowerResult.h"
 #include "model/UpdateQualityRuleRequest.h"
@@ -984,6 +988,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateMetaTableIntroWikiResult> UpdateMetaTableIntroWikiOutcome;
 			typedef std::future<UpdateMetaTableIntroWikiOutcome> UpdateMetaTableIntroWikiOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateMetaTableIntroWikiRequest&, const UpdateMetaTableIntroWikiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMetaTableIntroWikiAsyncHandler;
+			typedef Outcome<Error, Model::UpdateNodeOwnerResult> UpdateNodeOwnerOutcome;
+			typedef std::future<UpdateNodeOwnerOutcome> UpdateNodeOwnerOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateNodeOwnerRequest&, const UpdateNodeOwnerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateNodeOwnerAsyncHandler;
+			typedef Outcome<Error, Model::UpdateNodeRunModeResult> UpdateNodeRunModeOutcome;
+			typedef std::future<UpdateNodeRunModeOutcome> UpdateNodeRunModeOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateNodeRunModeRequest&, const UpdateNodeRunModeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateNodeRunModeAsyncHandler;
 			typedef Outcome<Error, Model::UpdateQualityFollowerResult> UpdateQualityFollowerOutcome;
 			typedef std::future<UpdateQualityFollowerOutcome> UpdateQualityFollowerOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateQualityFollowerRequest&, const UpdateQualityFollowerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateQualityFollowerAsyncHandler;
@@ -1577,6 +1587,12 @@ namespace AlibabaCloud
 			UpdateMetaTableIntroWikiOutcome updateMetaTableIntroWiki(const Model::UpdateMetaTableIntroWikiRequest &request)const;
 			void updateMetaTableIntroWikiAsync(const Model::UpdateMetaTableIntroWikiRequest& request, const UpdateMetaTableIntroWikiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateMetaTableIntroWikiOutcomeCallable updateMetaTableIntroWikiCallable(const Model::UpdateMetaTableIntroWikiRequest& request) const;
+			UpdateNodeOwnerOutcome updateNodeOwner(const Model::UpdateNodeOwnerRequest &request)const;
+			void updateNodeOwnerAsync(const Model::UpdateNodeOwnerRequest& request, const UpdateNodeOwnerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateNodeOwnerOutcomeCallable updateNodeOwnerCallable(const Model::UpdateNodeOwnerRequest& request) const;
+			UpdateNodeRunModeOutcome updateNodeRunMode(const Model::UpdateNodeRunModeRequest &request)const;
+			void updateNodeRunModeAsync(const Model::UpdateNodeRunModeRequest& request, const UpdateNodeRunModeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateNodeRunModeOutcomeCallable updateNodeRunModeCallable(const Model::UpdateNodeRunModeRequest& request) const;
 			UpdateQualityFollowerOutcome updateQualityFollower(const Model::UpdateQualityFollowerRequest &request)const;
 			void updateQualityFollowerAsync(const Model::UpdateQualityFollowerRequest& request, const UpdateQualityFollowerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateQualityFollowerOutcomeCallable updateQualityFollowerCallable(const Model::UpdateQualityFollowerRequest& request) const;

dataworks-public/include/alibabacloud/dataworks-public/model/CreateFileRequest.h

@@ -81,6 +81,8 @@ namespace AlibabaCloud
 				void setFileFolderPath(const std::string& fileFolderPath);
 				std::string getFileDescription()const;
 				void setFileDescription(const std::string& fileDescription);
+				bool getAutoParsing()const;
+				void setAutoParsing(bool autoParsing);
 
             private:
 				int fileType_;
@@ -106,6 +108,7 @@ namespace AlibabaCloud
 				std::string dependentType_;
 				std::string fileFolderPath_;
 				std::string fileDescription_;
+				bool autoParsing_;
 
 			};
 		}

dataworks-public/include/alibabacloud/dataworks-public/model/GetFileResult.h

@@ -53,6 +53,7 @@ namespace AlibabaCloud
 						long nodeId;
 						int commitStatus;
 						std::string deletedStatus;
+						bool autoParsing;
 						std::string fileFolderId;
 						long bizId;
 						long businessId;
@@ -62,6 +63,7 @@ namespace AlibabaCloud
 						struct NodeInputOutput
 						{
 							std::string input;
+							std::string parseType;
 						};
 						struct NodeInputOutput1
 						{

dataworks-public/include/alibabacloud/dataworks-public/model/ListFilesResult.h

@@ -53,6 +53,7 @@ namespace AlibabaCloud
 						long nodeId;
 						int commitStatus;
 						long fileId;
+						bool autoParsing;
 						std::string fileFolderId;
 						long bizId;
 						long businessId;

dataworks-public/include/alibabacloud/dataworks-public/model/UpdateFileRequest.h

@@ -81,6 +81,8 @@ namespace AlibabaCloud
 				void setFileFolderPath(const std::string& fileFolderPath);
 				std::string getFileDescription()const;
 				void setFileDescription(const std::string& fileDescription);
+				bool getAutoParsing()const;
+				void setAutoParsing(bool autoParsing);
 
             private:
 				std::string outputList_;
@@ -106,6 +108,7 @@ namespace AlibabaCloud
 				std::string dependentType_;
 				std::string fileFolderPath_;
 				std::string fileDescription_;
+				bool autoParsing_;
 
 			};
 		}

dataworks-public/include/alibabacloud/dataworks-public/model/UpdateNodeOwnerRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODEOWNERREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODEOWNERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT UpdateNodeOwnerRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateNodeOwnerRequest();
+				~UpdateNodeOwnerRequest();
+
+				std::string getProjectEnv()const;
+				void setProjectEnv(const std::string& projectEnv);
+				long getNodeId()const;
+				void setNodeId(long nodeId);
+				std::string getUserId()const;
+				void setUserId(const std::string& userId);
+
+            private:
+				std::string projectEnv_;
+				long nodeId_;
+				std::string userId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODEOWNERREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/UpdateNodeOwnerResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODEOWNERRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODEOWNERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT UpdateNodeOwnerResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateNodeOwnerResult();
+				explicit UpdateNodeOwnerResult(const std::string &payload);
+				~UpdateNodeOwnerResult();
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODEOWNERRESULT_H_

dataworks-public/include/alibabacloud/dataworks-public/model/UpdateNodeRunModeRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODERUNMODEREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODERUNMODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT UpdateNodeRunModeRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateNodeRunModeRequest();
+				~UpdateNodeRunModeRequest();
+
+				std::string getProjectEnv()const;
+				void setProjectEnv(const std::string& projectEnv);
+				int getSchedulerType()const;
+				void setSchedulerType(int schedulerType);
+				long getNodeId()const;
+				void setNodeId(long nodeId);
+
+            private:
+				std::string projectEnv_;
+				int schedulerType_;
+				long nodeId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODERUNMODEREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/UpdateNodeRunModeResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODERUNMODERESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODERUNMODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT UpdateNodeRunModeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateNodeRunModeResult();
+				explicit UpdateNodeRunModeResult(const std::string &payload);
+				~UpdateNodeRunModeResult();
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATENODERUNMODERESULT_H_

dataworks-public/src/Dataworks-publicClient.cc

@@ -6783,6 +6783,78 @@ Dataworks_publicClient::UpdateMetaTableIntroWikiOutcomeCallable Dataworks_public
 	return task->get_future();
 }
 
+Dataworks_publicClient::UpdateNodeOwnerOutcome Dataworks_publicClient::updateNodeOwner(const UpdateNodeOwnerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateNodeOwnerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateNodeOwnerOutcome(UpdateNodeOwnerResult(outcome.result()));
+	else
+		return UpdateNodeOwnerOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::updateNodeOwnerAsync(const UpdateNodeOwnerRequest& request, const UpdateNodeOwnerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateNodeOwner(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::UpdateNodeOwnerOutcomeCallable Dataworks_publicClient::updateNodeOwnerCallable(const UpdateNodeOwnerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateNodeOwnerOutcome()>>(
+			[this, request]()
+			{
+			return this->updateNodeOwner(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Dataworks_publicClient::UpdateNodeRunModeOutcome Dataworks_publicClient::updateNodeRunMode(const UpdateNodeRunModeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateNodeRunModeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateNodeRunModeOutcome(UpdateNodeRunModeResult(outcome.result()));
+	else
+		return UpdateNodeRunModeOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::updateNodeRunModeAsync(const UpdateNodeRunModeRequest& request, const UpdateNodeRunModeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateNodeRunMode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::UpdateNodeRunModeOutcomeCallable Dataworks_publicClient::updateNodeRunModeCallable(const UpdateNodeRunModeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateNodeRunModeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateNodeRunMode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::UpdateQualityFollowerOutcome Dataworks_publicClient::updateQualityFollower(const UpdateQualityFollowerRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dataworks-public/src/model/CreateFileRequest.cc

@@ -280,3 +280,14 @@ void CreateFileRequest::setFileDescription(const std::string& fileDescription)
 	setBodyParameter("FileDescription", fileDescription);
 }
 
+bool CreateFileRequest::getAutoParsing()const
+{
+	return autoParsing_;
+}
+
+void CreateFileRequest::setAutoParsing(bool autoParsing)
+{
+	autoParsing_ = autoParsing;
+	setBodyParameter("AutoParsing", autoParsing ? "true" : "false");
+}
+

dataworks-public/src/model/GetFileResult.cc

@@ -81,6 +81,8 @@ void GetFileResult::parse(const std::string &payload)
 		data_.file.deletedStatus = fileNode["DeletedStatus"].asString();
 	if(!fileNode["BusinessId"].isNull())
 		data_.file.businessId = std::stol(fileNode["BusinessId"].asString());
+	if(!fileNode["AutoParsing"].isNull())
+		data_.file.autoParsing = fileNode["AutoParsing"].asString() == "true";
 	auto nodeConfigurationNode = dataNode["NodeConfiguration"];
 	if(!nodeConfigurationNode["AutoRerunTimes"].isNull())
 		data_.nodeConfiguration.autoRerunTimes = std::stoi(nodeConfigurationNode["AutoRerunTimes"].asString());
@@ -112,6 +114,8 @@ void GetFileResult::parse(const std::string &payload)
 		Data::NodeConfiguration::NodeInputOutput nodeInputOutputObject;
 		if(!nodeConfigurationNodeInputListNodeInputOutput["Input"].isNull())
 			nodeInputOutputObject.input = nodeConfigurationNodeInputListNodeInputOutput["Input"].asString();
+		if(!nodeConfigurationNodeInputListNodeInputOutput["ParseType"].isNull())
+			nodeInputOutputObject.parseType = nodeConfigurationNodeInputListNodeInputOutput["ParseType"].asString();
 		data_.nodeConfiguration.inputList.push_back(nodeInputOutputObject);
 	}
 	auto allOutputListNode = nodeConfigurationNode["OutputList"]["NodeInputOutput"];

dataworks-public/src/model/ListFilesResult.cc

@@ -90,6 +90,8 @@ void ListFilesResult::parse(const std::string &payload)
 			fileObject.fileId = std::stol(dataNodeFilesFile["FileId"].asString());
 		if(!dataNodeFilesFile["BusinessId"].isNull())
 			fileObject.businessId = std::stol(dataNodeFilesFile["BusinessId"].asString());
+		if(!dataNodeFilesFile["AutoParsing"].isNull())
+			fileObject.autoParsing = dataNodeFilesFile["AutoParsing"].asString() == "true";
 		data_.files.push_back(fileObject);
 	}
 	if(!value["Success"].isNull())

dataworks-public/src/model/UpdateFileRequest.cc

@@ -280,3 +280,14 @@ void UpdateFileRequest::setFileDescription(const std::string& fileDescription)
 	setBodyParameter("FileDescription", fileDescription);
 }
 
+bool UpdateFileRequest::getAutoParsing()const
+{
+	return autoParsing_;
+}
+
+void UpdateFileRequest::setAutoParsing(bool autoParsing)
+{
+	autoParsing_ = autoParsing;
+	setBodyParameter("AutoParsing", autoParsing ? "true" : "false");
+}
+

dataworks-public/src/model/UpdateNodeOwnerRequest.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/dataworks-public/model/UpdateNodeOwnerRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::UpdateNodeOwnerRequest;
+
+UpdateNodeOwnerRequest::UpdateNodeOwnerRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "UpdateNodeOwner")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateNodeOwnerRequest::~UpdateNodeOwnerRequest()
+{}
+
+std::string UpdateNodeOwnerRequest::getProjectEnv()const
+{
+	return projectEnv_;
+}
+
+void UpdateNodeOwnerRequest::setProjectEnv(const std::string& projectEnv)
+{
+	projectEnv_ = projectEnv;
+	setBodyParameter("ProjectEnv", projectEnv);
+}
+
+long UpdateNodeOwnerRequest::getNodeId()const
+{
+	return nodeId_;
+}
+
+void UpdateNodeOwnerRequest::setNodeId(long nodeId)
+{
+	nodeId_ = nodeId;
+	setBodyParameter("NodeId", std::to_string(nodeId));
+}
+
+std::string UpdateNodeOwnerRequest::getUserId()const
+{
+	return userId_;
+}
+
+void UpdateNodeOwnerRequest::setUserId(const std::string& userId)
+{
+	userId_ = userId;
+	setBodyParameter("UserId", userId);
+}
+

dataworks-public/src/model/UpdateNodeOwnerResult.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/dataworks-public/model/UpdateNodeOwnerResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+UpdateNodeOwnerResult::UpdateNodeOwnerResult() :
+	ServiceResult()
+{}
+
+UpdateNodeOwnerResult::UpdateNodeOwnerResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateNodeOwnerResult::~UpdateNodeOwnerResult()
+{}
+
+void UpdateNodeOwnerResult::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";
+
+}
+
+bool UpdateNodeOwnerResult::getSuccess()const
+{
+	return success_;
+}
+

dataworks-public/src/model/UpdateNodeRunModeRequest.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/dataworks-public/model/UpdateNodeRunModeRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::UpdateNodeRunModeRequest;
+
+UpdateNodeRunModeRequest::UpdateNodeRunModeRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "UpdateNodeRunMode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateNodeRunModeRequest::~UpdateNodeRunModeRequest()
+{}
+
+std::string UpdateNodeRunModeRequest::getProjectEnv()const
+{
+	return projectEnv_;
+}
+
+void UpdateNodeRunModeRequest::setProjectEnv(const std::string& projectEnv)
+{
+	projectEnv_ = projectEnv;
+	setBodyParameter("ProjectEnv", projectEnv);
+}
+
+int UpdateNodeRunModeRequest::getSchedulerType()const
+{
+	return schedulerType_;
+}
+
+void UpdateNodeRunModeRequest::setSchedulerType(int schedulerType)
+{
+	schedulerType_ = schedulerType;
+	setBodyParameter("SchedulerType", std::to_string(schedulerType));
+}
+
+long UpdateNodeRunModeRequest::getNodeId()const
+{
+	return nodeId_;
+}
+
+void UpdateNodeRunModeRequest::setNodeId(long nodeId)
+{
+	nodeId_ = nodeId;
+	setBodyParameter("NodeId", std::to_string(nodeId));
+}
+

dataworks-public/src/model/UpdateNodeRunModeResult.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/dataworks-public/model/UpdateNodeRunModeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+UpdateNodeRunModeResult::UpdateNodeRunModeResult() :
+	ServiceResult()
+{}
+
+UpdateNodeRunModeResult::UpdateNodeRunModeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateNodeRunModeResult::~UpdateNodeRunModeResult()
+{}
+
+void UpdateNodeRunModeResult::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";
+
+}
+
+bool UpdateNodeRunModeResult::getSuccess()const
+{
+	return success_;
+}
+

dds/include/alibabacloud/dds/model/CreateDBInstanceRequest.h

@@ -81,6 +81,8 @@ namespace AlibabaCloud
 				void setStorageEngine(const std::string& storageEngine);
 				std::string getDatabaseNames()const;
 				void setDatabaseNames(const std::string& databaseNames);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 				std::string getEngine()const;
 				void setEngine(const std::string& engine);
 				std::string getRestoreTime()const;
@@ -124,6 +126,7 @@ namespace AlibabaCloud
 				std::string accessKeyId_;
 				std::string storageEngine_;
 				std::string databaseNames_;
+				std::string regionId_;
 				std::string engine_;
 				std::string restoreTime_;
 				std::string resourceOwnerAccount_;

dds/include/alibabacloud/dds/model/CreateShardingDBInstanceRequest.h

@@ -65,6 +65,8 @@ namespace AlibabaCloud
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getStorageEngine()const;
 				void setStorageEngine(const std::string& storageEngine);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
 				std::string getEngine()const;
@@ -112,6 +114,7 @@ namespace AlibabaCloud
 				std::vector<ReplicaSet> replicaSet_;
 				std::string accessKeyId_;
 				std::string storageEngine_;
+				std::string regionId_;
 				std::string securityToken_;
 				std::string engine_;
 				std::string dBInstanceDescription_;

dds/include/alibabacloud/dds/model/DescribeDBInstancesRequest.h

@@ -59,6 +59,8 @@ namespace AlibabaCloud
 				void setExpired(const std::string& expired);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 				std::string getEngine()const;
 				void setEngine(const std::string& engine);
 				int getPageSize()const;
@@ -104,6 +106,7 @@ namespace AlibabaCloud
 				std::string resourceGroupId_;
 				std::string expired_;
 				std::string securityToken_;
+				std::string regionId_;
 				std::string engine_;
 				int pageSize_;
 				std::string dBInstanceId_;

dds/include/alibabacloud/dds/model/DescribeDBInstancesResult.h

@@ -34,6 +34,11 @@ namespace AlibabaCloud
 			public:
 				struct DBInstance
 				{
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
 					struct MongosAttribute
 					{
 						std::string nodeClass;
@@ -45,19 +50,14 @@ namespace AlibabaCloud
 						std::string nodeClass;
 						std::string nodeDescription;
 						int readonlyReplicas;
-						std::string nodeId;
 						int nodeStorage;
-					};
-					struct Tag
-					{
-						std::string value;
-						std::string key;
+						std::string nodeId;
 					};
 					std::string engineVersion;
-					std::string replicationFactor;
-					std::string zoneId;
-					std::string resourceGroupId;
 					std::string dBInstanceStatus;
+					std::string resourceGroupId;
+					std::string zoneId;
+					std::string replicationFactor;
 					std::string dBInstanceClass;
 					std::string destroyTime;
 					std::vector<DBInstance::ShardAttribute> shardList;
@@ -65,18 +65,18 @@ namespace AlibabaCloud
 					std::string lockMode;
 					std::vector<DBInstance::MongosAttribute> mongosList;
 					std::string dBInstanceId;
-					std::string networkType;
-					std::string vpcAuthMode;
 					std::string chargeType;
-					int dBInstanceStorage;
+					std::string vpcAuthMode;
+					std::string networkType;
 					std::string lastDowngradeTime;
+					int dBInstanceStorage;
 					std::string creationTime;
 					std::string regionId;
 					std::string expireTime;
 					std::string kindCode;
 					std::vector<DBInstance::Tag> tags;
-					std::string engine;
 					std::string dBInstanceDescription;
+					std::string engine;
 				};
 
 

dds/include/alibabacloud/dds/model/DescribeParameterTemplatesRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 				std::string getEngine()const;
 				void setEngine(const std::string& engine);
 				std::string getResourceOwnerAccount()const;
@@ -57,6 +59,7 @@ namespace AlibabaCloud
 				std::string engineVersion_;
 				std::string accessKeyId_;
 				std::string securityToken_;
+				std::string regionId_;
 				std::string engine_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;

dds/include/alibabacloud/dds/model/DescribePriceRequest.h

@@ -47,6 +47,8 @@ namespace AlibabaCloud
 				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 				std::string getBusinessInfo()const;
 				void setBusinessInfo(const std::string& businessInfo);
 				std::string getResourceOwnerAccount()const;
@@ -71,6 +73,7 @@ namespace AlibabaCloud
 				std::string accessKeyId_;
 				std::string resourceGroupId_;
 				std::string securityToken_;
+				std::string regionId_;
 				std::string businessInfo_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;

dds/include/alibabacloud/dds/model/ModifyNodeSpecRequest.h

@@ -41,8 +41,6 @@ namespace AlibabaCloud
 				void setClientToken(const std::string& clientToken);
 				int getReadonlyReplicas()const;
 				void setReadonlyReplicas(int readonlyReplicas);
-				std::string getCouponNo()const;
-				void setCouponNo(const std::string& couponNo);
 				std::string getNodeClass()const;
 				void setNodeClass(const std::string& nodeClass);
 				std::string getAccessKeyId()const;
@@ -53,12 +51,8 @@ namespace AlibabaCloud
 				void setEffectiveTime(const std::string& effectiveTime);
 				std::string getDBInstanceId()const;
 				void setDBInstanceId(const std::string& dBInstanceId);
-				std::string getSwitchTime()const;
-				void setSwitchTime(const std::string& switchTime);
 				std::string getNodeId()const;
 				void setNodeId(const std::string& nodeId);
-				std::string getBusinessInfo()const;
-				void setBusinessInfo(const std::string& businessInfo);
 				bool getAutoPay()const;
 				void setAutoPay(bool autoPay);
 				std::string getFromApp()const;
@@ -78,15 +72,12 @@ namespace AlibabaCloud
 				long resourceOwnerId_;
 				std::string clientToken_;
 				int readonlyReplicas_;
-				std::string couponNo_;
 				std::string nodeClass_;
 				std::string accessKeyId_;
 				std::string securityToken_;
 				std::string effectiveTime_;
 				std::string dBInstanceId_;
-				std::string switchTime_;
 				std::string nodeId_;
-				std::string businessInfo_;
 				bool autoPay_;
 				std::string fromApp_;
 				std::string resourceOwnerAccount_;

dds/src/DdsClient.cc

@@ -31,21 +31,21 @@ DdsClient::DdsClient(const Credentials &credentials, const ClientConfiguration &
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "Dds");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 DdsClient::DdsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "Dds");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 DdsClient::DdsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "Dds");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 DdsClient::~DdsClient()

dds/src/model/CreateDBInstanceRequest.cc

@@ -280,6 +280,17 @@ void CreateDBInstanceRequest::setDatabaseNames(const std::string& databaseNames)
 	setParameter("DatabaseNames", databaseNames);
 }
 
+std::string CreateDBInstanceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateDBInstanceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
 std::string CreateDBInstanceRequest::getEngine()const
 {
 	return engine_;

dds/src/model/CreateShardingDBInstanceRequest.cc

@@ -110,6 +110,17 @@ void CreateShardingDBInstanceRequest::setStorageEngine(const std::string& storag
 	setParameter("StorageEngine", storageEngine);
 }
 
+std::string CreateShardingDBInstanceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateShardingDBInstanceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
 std::string CreateShardingDBInstanceRequest::getSecurityToken()const
 {
 	return securityToken_;

dds/src/model/DescribeDBInstancesRequest.cc

@@ -126,6 +126,17 @@ void DescribeDBInstancesRequest::setSecurityToken(const std::string& securityTok
 	setParameter("SecurityToken", securityToken);
 }
 
+std::string DescribeDBInstancesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeDBInstancesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
 std::string DescribeDBInstancesRequest::getEngine()const
 {
 	return engine_;

dds/src/model/DescribeDBInstancesResult.cc

@@ -43,48 +43,58 @@ void DescribeDBInstancesResult::parse(const std::string &payload)
 	for (auto valueDBInstancesDBInstance : allDBInstancesNode)
 	{
 		DBInstance dBInstancesObject;
-		if(!valueDBInstancesDBInstance["EngineVersion"].isNull())
-			dBInstancesObject.engineVersion = valueDBInstancesDBInstance["EngineVersion"].asString();
-		if(!valueDBInstancesDBInstance["ReplicationFactor"].isNull())
-			dBInstancesObject.replicationFactor = valueDBInstancesDBInstance["ReplicationFactor"].asString();
-		if(!valueDBInstancesDBInstance["ZoneId"].isNull())
-			dBInstancesObject.zoneId = valueDBInstancesDBInstance["ZoneId"].asString();
-		if(!valueDBInstancesDBInstance["ResourceGroupId"].isNull())
-			dBInstancesObject.resourceGroupId = valueDBInstancesDBInstance["ResourceGroupId"].asString();
-		if(!valueDBInstancesDBInstance["DBInstanceStatus"].isNull())
-			dBInstancesObject.dBInstanceStatus = valueDBInstancesDBInstance["DBInstanceStatus"].asString();
-		if(!valueDBInstancesDBInstance["DBInstanceClass"].isNull())
-			dBInstancesObject.dBInstanceClass = valueDBInstancesDBInstance["DBInstanceClass"].asString();
-		if(!valueDBInstancesDBInstance["DestroyTime"].isNull())
-			dBInstancesObject.destroyTime = valueDBInstancesDBInstance["DestroyTime"].asString();
-		if(!valueDBInstancesDBInstance["DBInstanceType"].isNull())
-			dBInstancesObject.dBInstanceType = valueDBInstancesDBInstance["DBInstanceType"].asString();
-		if(!valueDBInstancesDBInstance["LockMode"].isNull())
-			dBInstancesObject.lockMode = valueDBInstancesDBInstance["LockMode"].asString();
-		if(!valueDBInstancesDBInstance["DBInstanceId"].isNull())
-			dBInstancesObject.dBInstanceId = valueDBInstancesDBInstance["DBInstanceId"].asString();
-		if(!valueDBInstancesDBInstance["NetworkType"].isNull())
-			dBInstancesObject.networkType = valueDBInstancesDBInstance["NetworkType"].asString();
-		if(!valueDBInstancesDBInstance["VpcAuthMode"].isNull())
-			dBInstancesObject.vpcAuthMode = valueDBInstancesDBInstance["VpcAuthMode"].asString();
-		if(!valueDBInstancesDBInstance["ChargeType"].isNull())
-			dBInstancesObject.chargeType = valueDBInstancesDBInstance["ChargeType"].asString();
-		if(!valueDBInstancesDBInstance["DBInstanceStorage"].isNull())
-			dBInstancesObject.dBInstanceStorage = std::stoi(valueDBInstancesDBInstance["DBInstanceStorage"].asString());
-		if(!valueDBInstancesDBInstance["LastDowngradeTime"].isNull())
-			dBInstancesObject.lastDowngradeTime = valueDBInstancesDBInstance["LastDowngradeTime"].asString();
 		if(!valueDBInstancesDBInstance["CreationTime"].isNull())
 			dBInstancesObject.creationTime = valueDBInstancesDBInstance["CreationTime"].asString();
-		if(!valueDBInstancesDBInstance["RegionId"].isNull())
-			dBInstancesObject.regionId = valueDBInstancesDBInstance["RegionId"].asString();
-		if(!valueDBInstancesDBInstance["ExpireTime"].isNull())
-			dBInstancesObject.expireTime = valueDBInstancesDBInstance["ExpireTime"].asString();
-		if(!valueDBInstancesDBInstance["KindCode"].isNull())
-			dBInstancesObject.kindCode = valueDBInstancesDBInstance["KindCode"].asString();
-		if(!valueDBInstancesDBInstance["Engine"].isNull())
-			dBInstancesObject.engine = valueDBInstancesDBInstance["Engine"].asString();
+		if(!valueDBInstancesDBInstance["ChargeType"].isNull())
+			dBInstancesObject.chargeType = valueDBInstancesDBInstance["ChargeType"].asString();
+		if(!valueDBInstancesDBInstance["VpcAuthMode"].isNull())
+			dBInstancesObject.vpcAuthMode = valueDBInstancesDBInstance["VpcAuthMode"].asString();
+		if(!valueDBInstancesDBInstance["NetworkType"].isNull())
+			dBInstancesObject.networkType = valueDBInstancesDBInstance["NetworkType"].asString();
+		if(!valueDBInstancesDBInstance["LockMode"].isNull())
+			dBInstancesObject.lockMode = valueDBInstancesDBInstance["LockMode"].asString();
+		if(!valueDBInstancesDBInstance["EngineVersion"].isNull())
+			dBInstancesObject.engineVersion = valueDBInstancesDBInstance["EngineVersion"].asString();
 		if(!valueDBInstancesDBInstance["DBInstanceDescription"].isNull())
 			dBInstancesObject.dBInstanceDescription = valueDBInstancesDBInstance["DBInstanceDescription"].asString();
+		if(!valueDBInstancesDBInstance["ExpireTime"].isNull())
+			dBInstancesObject.expireTime = valueDBInstancesDBInstance["ExpireTime"].asString();
+		if(!valueDBInstancesDBInstance["DBInstanceType"].isNull())
+			dBInstancesObject.dBInstanceType = valueDBInstancesDBInstance["DBInstanceType"].asString();
+		if(!valueDBInstancesDBInstance["LastDowngradeTime"].isNull())
+			dBInstancesObject.lastDowngradeTime = valueDBInstancesDBInstance["LastDowngradeTime"].asString();
+		if(!valueDBInstancesDBInstance["DestroyTime"].isNull())
+			dBInstancesObject.destroyTime = valueDBInstancesDBInstance["DestroyTime"].asString();
+		if(!valueDBInstancesDBInstance["DBInstanceStatus"].isNull())
+			dBInstancesObject.dBInstanceStatus = valueDBInstancesDBInstance["DBInstanceStatus"].asString();
+		if(!valueDBInstancesDBInstance["RegionId"].isNull())
+			dBInstancesObject.regionId = valueDBInstancesDBInstance["RegionId"].asString();
+		if(!valueDBInstancesDBInstance["DBInstanceStorage"].isNull())
+			dBInstancesObject.dBInstanceStorage = std::stoi(valueDBInstancesDBInstance["DBInstanceStorage"].asString());
+		if(!valueDBInstancesDBInstance["ResourceGroupId"].isNull())
+			dBInstancesObject.resourceGroupId = valueDBInstancesDBInstance["ResourceGroupId"].asString();
+		if(!valueDBInstancesDBInstance["ZoneId"].isNull())
+			dBInstancesObject.zoneId = valueDBInstancesDBInstance["ZoneId"].asString();
+		if(!valueDBInstancesDBInstance["DBInstanceId"].isNull())
+			dBInstancesObject.dBInstanceId = valueDBInstancesDBInstance["DBInstanceId"].asString();
+		if(!valueDBInstancesDBInstance["DBInstanceClass"].isNull())
+			dBInstancesObject.dBInstanceClass = valueDBInstancesDBInstance["DBInstanceClass"].asString();
+		if(!valueDBInstancesDBInstance["Engine"].isNull())
+			dBInstancesObject.engine = valueDBInstancesDBInstance["Engine"].asString();
+		if(!valueDBInstancesDBInstance["ReplicationFactor"].isNull())
+			dBInstancesObject.replicationFactor = valueDBInstancesDBInstance["ReplicationFactor"].asString();
+		if(!valueDBInstancesDBInstance["KindCode"].isNull())
+			dBInstancesObject.kindCode = valueDBInstancesDBInstance["KindCode"].asString();
+		auto allTagsNode = valueDBInstancesDBInstance["Tags"]["Tag"];
+		for (auto valueDBInstancesDBInstanceTagsTag : allTagsNode)
+		{
+			DBInstance::Tag tagsObject;
+			if(!valueDBInstancesDBInstanceTagsTag["Key"].isNull())
+				tagsObject.key = valueDBInstancesDBInstanceTagsTag["Key"].asString();
+			if(!valueDBInstancesDBInstanceTagsTag["Value"].isNull())
+				tagsObject.value = valueDBInstancesDBInstanceTagsTag["Value"].asString();
+			dBInstancesObject.tags.push_back(tagsObject);
+		}
 		auto allMongosListNode = valueDBInstancesDBInstance["MongosList"]["MongosAttribute"];
 		for (auto valueDBInstancesDBInstanceMongosListMongosAttribute : allMongosListNode)
 		{
@@ -105,24 +115,14 @@ void DescribeDBInstancesResult::parse(const std::string &payload)
 				shardListObject.nodeClass = valueDBInstancesDBInstanceShardListShardAttribute["NodeClass"].asString();
 			if(!valueDBInstancesDBInstanceShardListShardAttribute["NodeDescription"].isNull())
 				shardListObject.nodeDescription = valueDBInstancesDBInstanceShardListShardAttribute["NodeDescription"].asString();
-			if(!valueDBInstancesDBInstanceShardListShardAttribute["ReadonlyReplicas"].isNull())
-				shardListObject.readonlyReplicas = std::stoi(valueDBInstancesDBInstanceShardListShardAttribute["ReadonlyReplicas"].asString());
-			if(!valueDBInstancesDBInstanceShardListShardAttribute["NodeId"].isNull())
-				shardListObject.nodeId = valueDBInstancesDBInstanceShardListShardAttribute["NodeId"].asString();
 			if(!valueDBInstancesDBInstanceShardListShardAttribute["NodeStorage"].isNull())
 				shardListObject.nodeStorage = std::stoi(valueDBInstancesDBInstanceShardListShardAttribute["NodeStorage"].asString());
+			if(!valueDBInstancesDBInstanceShardListShardAttribute["NodeId"].isNull())
+				shardListObject.nodeId = valueDBInstancesDBInstanceShardListShardAttribute["NodeId"].asString();
+			if(!valueDBInstancesDBInstanceShardListShardAttribute["ReadonlyReplicas"].isNull())
+				shardListObject.readonlyReplicas = std::stoi(valueDBInstancesDBInstanceShardListShardAttribute["ReadonlyReplicas"].asString());
 			dBInstancesObject.shardList.push_back(shardListObject);
 		}
-		auto allTagsNode = valueDBInstancesDBInstance["Tags"]["Tag"];
-		for (auto valueDBInstancesDBInstanceTagsTag : allTagsNode)
-		{
-			DBInstance::Tag tagsObject;
-			if(!valueDBInstancesDBInstanceTagsTag["Value"].isNull())
-				tagsObject.value = valueDBInstancesDBInstanceTagsTag["Value"].asString();
-			if(!valueDBInstancesDBInstanceTagsTag["Key"].isNull())
-				tagsObject.key = valueDBInstancesDBInstanceTagsTag["Key"].asString();
-			dBInstancesObject.tags.push_back(tagsObject);
-		}
 		dBInstances_.push_back(dBInstancesObject);
 	}
 	if(!value["TotalCount"].isNull())

dds/src/model/DescribeParameterTemplatesRequest.cc

@@ -71,6 +71,17 @@ void DescribeParameterTemplatesRequest::setSecurityToken(const std::string& secu
 	setParameter("SecurityToken", securityToken);
 }
 
+std::string DescribeParameterTemplatesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeParameterTemplatesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
 std::string DescribeParameterTemplatesRequest::getEngine()const
 {
 	return engine_;

dds/src/model/DescribeParameterTemplatesResult.cc

@@ -43,6 +43,8 @@ void DescribeParameterTemplatesResult::parse(const std::string &payload)
 	for (auto valueParametersTemplateRecord : allParametersNode)
 	{
 		TemplateRecord parametersObject;
+		if(!valueParametersTemplateRecord["CheckingCode"].isNull())
+			parametersObject.checkingCode = valueParametersTemplateRecord["CheckingCode"].asString();
 		if(!valueParametersTemplateRecord["ParameterName"].isNull())
 			parametersObject.parameterName = valueParametersTemplateRecord["ParameterName"].asString();
 		if(!valueParametersTemplateRecord["ParameterValue"].isNull())
@@ -51,18 +53,16 @@ void DescribeParameterTemplatesResult::parse(const std::string &payload)
 			parametersObject.forceModify = valueParametersTemplateRecord["ForceModify"].asString() == "true";
 		if(!valueParametersTemplateRecord["ForceRestart"].isNull())
 			parametersObject.forceRestart = valueParametersTemplateRecord["ForceRestart"].asString() == "true";
-		if(!valueParametersTemplateRecord["CheckingCode"].isNull())
-			parametersObject.checkingCode = valueParametersTemplateRecord["CheckingCode"].asString();
 		if(!valueParametersTemplateRecord["ParameterDescription"].isNull())
 			parametersObject.parameterDescription = valueParametersTemplateRecord["ParameterDescription"].asString();
 		parameters_.push_back(parametersObject);
 	}
-	if(!value["Engine"].isNull())
-		engine_ = value["Engine"].asString();
-	if(!value["EngineVersion"].isNull())
-		engineVersion_ = value["EngineVersion"].asString();
 	if(!value["ParameterCount"].isNull())
 		parameterCount_ = value["ParameterCount"].asString();
+	if(!value["EngineVersion"].isNull())
+		engineVersion_ = value["EngineVersion"].asString();
+	if(!value["Engine"].isNull())
+		engine_ = value["Engine"].asString();
 
 }
 

dds/src/model/DescribePriceRequest.cc

@@ -93,6 +93,17 @@ void DescribePriceRequest::setSecurityToken(const std::string& securityToken)
 	setParameter("SecurityToken", securityToken);
 }
 
+std::string DescribePriceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribePriceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
 std::string DescribePriceRequest::getBusinessInfo()const
 {
 	return businessInfo_;

dds/src/model/DescribePriceResult.cc

@@ -43,14 +43,14 @@ void DescribePriceResult::parse(const std::string &payload)
 	for (auto valueSubOrdersSubOrder : allSubOrdersNode)
 	{
 		SubOrder subOrdersObject;
-		if(!valueSubOrdersSubOrder["InstanceId"].isNull())
-			subOrdersObject.instanceId = valueSubOrdersSubOrder["InstanceId"].asString();
-		if(!valueSubOrdersSubOrder["TradeAmount"].isNull())
-			subOrdersObject.tradeAmount = valueSubOrdersSubOrder["TradeAmount"].asString();
 		if(!valueSubOrdersSubOrder["OriginalAmount"].isNull())
 			subOrdersObject.originalAmount = valueSubOrdersSubOrder["OriginalAmount"].asString();
 		if(!valueSubOrdersSubOrder["DiscountAmount"].isNull())
 			subOrdersObject.discountAmount = valueSubOrdersSubOrder["DiscountAmount"].asString();
+		if(!valueSubOrdersSubOrder["TradeAmount"].isNull())
+			subOrdersObject.tradeAmount = valueSubOrdersSubOrder["TradeAmount"].asString();
+		if(!valueSubOrdersSubOrder["InstanceId"].isNull())
+			subOrdersObject.instanceId = valueSubOrdersSubOrder["InstanceId"].asString();
 		auto allRuleIds = value["RuleIds"]["RuleId"];
 		for (auto value : allRuleIds)
 			subOrdersObject.ruleIds.push_back(value.asString());
@@ -69,24 +69,24 @@ void DescribePriceResult::parse(const std::string &payload)
 		rules_.push_back(rulesObject);
 	}
 	auto orderNode = value["Order"];
-	if(!orderNode["Currency"].isNull())
-		order_.currency = orderNode["Currency"].asString();
-	if(!orderNode["TradeAmount"].isNull())
-		order_.tradeAmount = orderNode["TradeAmount"].asString();
 	if(!orderNode["OriginalAmount"].isNull())
 		order_.originalAmount = orderNode["OriginalAmount"].asString();
 	if(!orderNode["DiscountAmount"].isNull())
 		order_.discountAmount = orderNode["DiscountAmount"].asString();
+	if(!orderNode["TradeAmount"].isNull())
+		order_.tradeAmount = orderNode["TradeAmount"].asString();
+	if(!orderNode["Currency"].isNull())
+		order_.currency = orderNode["Currency"].asString();
 	auto allCouponsNode = orderNode["Coupons"]["Coupon"];
 	for (auto orderNodeCouponsCoupon : allCouponsNode)
 	{
 		Order::Coupon couponObject;
-		if(!orderNodeCouponsCoupon["CouponNo"].isNull())
-			couponObject.couponNo = orderNodeCouponsCoupon["CouponNo"].asString();
 		if(!orderNodeCouponsCoupon["Description"].isNull())
 			couponObject.description = orderNodeCouponsCoupon["Description"].asString();
 		if(!orderNodeCouponsCoupon["IsSelected"].isNull())
 			couponObject.isSelected = orderNodeCouponsCoupon["IsSelected"].asString();
+		if(!orderNodeCouponsCoupon["CouponNo"].isNull())
+			couponObject.couponNo = orderNodeCouponsCoupon["CouponNo"].asString();
 		if(!orderNodeCouponsCoupon["Name"].isNull())
 			couponObject.name = orderNodeCouponsCoupon["Name"].asString();
 		order_.coupons.push_back(couponObject);

dds/src/model/ModifyNodeSpecRequest.cc

@@ -60,17 +60,6 @@ void ModifyNodeSpecRequest::setReadonlyReplicas(int readonlyReplicas)
 	setParameter("ReadonlyReplicas", std::to_string(readonlyReplicas));
 }
 
-std::string ModifyNodeSpecRequest::getCouponNo()const
-{
-	return couponNo_;
-}
-
-void ModifyNodeSpecRequest::setCouponNo(const std::string& couponNo)
-{
-	couponNo_ = couponNo;
-	setParameter("CouponNo", couponNo);
-}
-
 std::string ModifyNodeSpecRequest::getNodeClass()const
 {
 	return nodeClass_;
@@ -126,17 +115,6 @@ void ModifyNodeSpecRequest::setDBInstanceId(const std::string& dBInstanceId)
 	setParameter("DBInstanceId", dBInstanceId);
 }
 
-std::string ModifyNodeSpecRequest::getSwitchTime()const
-{
-	return switchTime_;
-}
-
-void ModifyNodeSpecRequest::setSwitchTime(const std::string& switchTime)
-{
-	switchTime_ = switchTime;
-	setParameter("SwitchTime", switchTime);
-}
-
 std::string ModifyNodeSpecRequest::getNodeId()const
 {
 	return nodeId_;
@@ -148,17 +126,6 @@ void ModifyNodeSpecRequest::setNodeId(const std::string& nodeId)
 	setParameter("NodeId", nodeId);
 }
 
-std::string ModifyNodeSpecRequest::getBusinessInfo()const
-{
-	return businessInfo_;
-}
-
-void ModifyNodeSpecRequest::setBusinessInfo(const std::string& businessInfo)
-{
-	businessInfo_ = businessInfo;
-	setParameter("BusinessInfo", businessInfo);
-}
-
 bool ModifyNodeSpecRequest::getAutoPay()const
 {
 	return autoPay_;

drds/CMakeLists.txt

@@ -145,6 +145,8 @@ set(drds_public_header_model
 	include/alibabacloud/drds/model/EnableSqlAuditResult.h
 	include/alibabacloud/drds/model/EnableSqlFlashbackMatchSwitchRequest.h
 	include/alibabacloud/drds/model/EnableSqlFlashbackMatchSwitchResult.h
+	include/alibabacloud/drds/model/GetDrdsDbRdsRelationInfoRequest.h
+	include/alibabacloud/drds/model/GetDrdsDbRdsRelationInfoResult.h
 	include/alibabacloud/drds/model/ListTagResourcesRequest.h
 	include/alibabacloud/drds/model/ListTagResourcesResult.h
 	include/alibabacloud/drds/model/ManagePrivateRdsRequest.h
@@ -342,6 +344,8 @@ set(drds_src
 	src/model/EnableSqlAuditResult.cc
 	src/model/EnableSqlFlashbackMatchSwitchRequest.cc
 	src/model/EnableSqlFlashbackMatchSwitchResult.cc
+	src/model/GetDrdsDbRdsRelationInfoRequest.cc
+	src/model/GetDrdsDbRdsRelationInfoResult.cc
 	src/model/ListTagResourcesRequest.cc
 	src/model/ListTagResourcesResult.cc
 	src/model/ManagePrivateRdsRequest.cc

drds/include/alibabacloud/drds/DrdsClient.h

@@ -146,6 +146,8 @@
 #include "model/EnableSqlAuditResult.h"
 #include "model/EnableSqlFlashbackMatchSwitchRequest.h"
 #include "model/EnableSqlFlashbackMatchSwitchResult.h"
+#include "model/GetDrdsDbRdsRelationInfoRequest.h"
+#include "model/GetDrdsDbRdsRelationInfoResult.h"
 #include "model/ListTagResourcesRequest.h"
 #include "model/ListTagResourcesResult.h"
 #include "model/ManagePrivateRdsRequest.h"
@@ -411,6 +413,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::EnableSqlFlashbackMatchSwitchResult> EnableSqlFlashbackMatchSwitchOutcome;
 			typedef std::future<EnableSqlFlashbackMatchSwitchOutcome> EnableSqlFlashbackMatchSwitchOutcomeCallable;
 			typedef std::function<void(const DrdsClient*, const Model::EnableSqlFlashbackMatchSwitchRequest&, const EnableSqlFlashbackMatchSwitchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableSqlFlashbackMatchSwitchAsyncHandler;
+			typedef Outcome<Error, Model::GetDrdsDbRdsRelationInfoResult> GetDrdsDbRdsRelationInfoOutcome;
+			typedef std::future<GetDrdsDbRdsRelationInfoOutcome> GetDrdsDbRdsRelationInfoOutcomeCallable;
+			typedef std::function<void(const DrdsClient*, const Model::GetDrdsDbRdsRelationInfoRequest&, const GetDrdsDbRdsRelationInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDrdsDbRdsRelationInfoAsyncHandler;
 			typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
 			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
 			typedef std::function<void(const DrdsClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
@@ -707,6 +712,9 @@ namespace AlibabaCloud
 			EnableSqlFlashbackMatchSwitchOutcome enableSqlFlashbackMatchSwitch(const Model::EnableSqlFlashbackMatchSwitchRequest &request)const;
 			void enableSqlFlashbackMatchSwitchAsync(const Model::EnableSqlFlashbackMatchSwitchRequest& request, const EnableSqlFlashbackMatchSwitchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableSqlFlashbackMatchSwitchOutcomeCallable enableSqlFlashbackMatchSwitchCallable(const Model::EnableSqlFlashbackMatchSwitchRequest& request) const;
+			GetDrdsDbRdsRelationInfoOutcome getDrdsDbRdsRelationInfo(const Model::GetDrdsDbRdsRelationInfoRequest &request)const;
+			void getDrdsDbRdsRelationInfoAsync(const Model::GetDrdsDbRdsRelationInfoRequest& request, const GetDrdsDbRdsRelationInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDrdsDbRdsRelationInfoOutcomeCallable getDrdsDbRdsRelationInfoCallable(const Model::GetDrdsDbRdsRelationInfoRequest& request) const;
 			ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
 			void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;

drds/include/alibabacloud/drds/model/GetDrdsDbRdsRelationInfoRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DRDS_MODEL_GETDRDSDBRDSRELATIONINFOREQUEST_H_
+#define ALIBABACLOUD_DRDS_MODEL_GETDRDSDBRDSRELATIONINFOREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/drds/DrdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Drds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DRDS_EXPORT GetDrdsDbRdsRelationInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetDrdsDbRdsRelationInfoRequest();
+				~GetDrdsDbRdsRelationInfoRequest();
+
+				std::string getDrdsInstanceId()const;
+				void setDrdsInstanceId(const std::string& drdsInstanceId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
+
+            private:
+				std::string drdsInstanceId_;
+				std::string accessKeyId_;
+				std::string dbName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DRDS_MODEL_GETDRDSDBRDSRELATIONINFOREQUEST_H_

drds/include/alibabacloud/drds/model/GetDrdsDbRdsRelationInfoResult.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DRDS_MODEL_GETDRDSDBRDSRELATIONINFORESULT_H_
+#define ALIBABACLOUD_DRDS_MODEL_GETDRDSDBRDSRELATIONINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/drds/DrdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Drds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DRDS_EXPORT GetDrdsDbRdsRelationInfoResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					std::string usedInstanceId;
+					std::vector<std::string> readOnlyInstanceInfo;
+					std::string usedInstanceType;
+					std::string rdsInstanceId;
+				};
+
+
+				GetDrdsDbRdsRelationInfoResult();
+				explicit GetDrdsDbRdsRelationInfoResult(const std::string &payload);
+				~GetDrdsDbRdsRelationInfoResult();
+				std::vector<DataItem> getData()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DataItem> data_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DRDS_MODEL_GETDRDSDBRDSRELATIONINFORESULT_H_

drds/src/DrdsClient.cc

@@ -2283,6 +2283,42 @@ DrdsClient::EnableSqlFlashbackMatchSwitchOutcomeCallable DrdsClient::enableSqlFl
 	return task->get_future();
 }
 
+DrdsClient::GetDrdsDbRdsRelationInfoOutcome DrdsClient::getDrdsDbRdsRelationInfo(const GetDrdsDbRdsRelationInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDrdsDbRdsRelationInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDrdsDbRdsRelationInfoOutcome(GetDrdsDbRdsRelationInfoResult(outcome.result()));
+	else
+		return GetDrdsDbRdsRelationInfoOutcome(outcome.error());
+}
+
+void DrdsClient::getDrdsDbRdsRelationInfoAsync(const GetDrdsDbRdsRelationInfoRequest& request, const GetDrdsDbRdsRelationInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDrdsDbRdsRelationInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DrdsClient::GetDrdsDbRdsRelationInfoOutcomeCallable DrdsClient::getDrdsDbRdsRelationInfoCallable(const GetDrdsDbRdsRelationInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDrdsDbRdsRelationInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->getDrdsDbRdsRelationInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DrdsClient::ListTagResourcesOutcome DrdsClient::listTagResources(const ListTagResourcesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

drds/src/model/GetDrdsDbRdsRelationInfoRequest.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/drds/model/GetDrdsDbRdsRelationInfoRequest.h>
+
+using AlibabaCloud::Drds::Model::GetDrdsDbRdsRelationInfoRequest;
+
+GetDrdsDbRdsRelationInfoRequest::GetDrdsDbRdsRelationInfoRequest() :
+	RpcServiceRequest("drds", "2019-01-23", "GetDrdsDbRdsRelationInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetDrdsDbRdsRelationInfoRequest::~GetDrdsDbRdsRelationInfoRequest()
+{}
+
+std::string GetDrdsDbRdsRelationInfoRequest::getDrdsInstanceId()const
+{
+	return drdsInstanceId_;
+}
+
+void GetDrdsDbRdsRelationInfoRequest::setDrdsInstanceId(const std::string& drdsInstanceId)
+{
+	drdsInstanceId_ = drdsInstanceId;
+	setParameter("DrdsInstanceId", drdsInstanceId);
+}
+
+std::string GetDrdsDbRdsRelationInfoRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void GetDrdsDbRdsRelationInfoRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string GetDrdsDbRdsRelationInfoRequest::getDbName()const
+{
+	return dbName_;
+}
+
+void GetDrdsDbRdsRelationInfoRequest::setDbName(const std::string& dbName)
+{
+	dbName_ = dbName;
+	setParameter("DbName", dbName);
+}
+

drds/src/model/GetDrdsDbRdsRelationInfoResult.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/drds/model/GetDrdsDbRdsRelationInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Drds;
+using namespace AlibabaCloud::Drds::Model;
+
+GetDrdsDbRdsRelationInfoResult::GetDrdsDbRdsRelationInfoResult() :
+	ServiceResult()
+{}
+
+GetDrdsDbRdsRelationInfoResult::GetDrdsDbRdsRelationInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetDrdsDbRdsRelationInfoResult::~GetDrdsDbRdsRelationInfoResult()
+{}
+
+void GetDrdsDbRdsRelationInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["RdsInstanceId"].isNull())
+			dataObject.rdsInstanceId = valueDataDataItem["RdsInstanceId"].asString();
+		if(!valueDataDataItem["UsedInstanceId"].isNull())
+			dataObject.usedInstanceId = valueDataDataItem["UsedInstanceId"].asString();
+		if(!valueDataDataItem["UsedInstanceType"].isNull())
+			dataObject.usedInstanceType = valueDataDataItem["UsedInstanceType"].asString();
+		auto allReadOnlyInstanceInfo = value["ReadOnlyInstanceInfo"]["ReadOnlyInstanceIds"];
+		for (auto value : allReadOnlyInstanceInfo)
+			dataObject.readOnlyInstanceInfo.push_back(value.asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::vector<GetDrdsDbRdsRelationInfoResult::DataItem> GetDrdsDbRdsRelationInfoResult::getData()const
+{
+	return data_;
+}
+
+bool GetDrdsDbRdsRelationInfoResult::getSuccess()const
+{
+	return success_;
+}
+

ehpc/CMakeLists.txt

@@ -23,6 +23,8 @@ set(ehpc_public_header
 set(ehpc_public_header_model 
 	include/alibabacloud/ehpc/model/AddContainerAppRequest.h
 	include/alibabacloud/ehpc/model/AddContainerAppResult.h
+	include/alibabacloud/ehpc/model/AddExistedNodesRequest.h
+	include/alibabacloud/ehpc/model/AddExistedNodesResult.h
 	include/alibabacloud/ehpc/model/AddLocalNodesRequest.h
 	include/alibabacloud/ehpc/model/AddLocalNodesResult.h
 	include/alibabacloud/ehpc/model/AddNodesRequest.h
@@ -99,6 +101,8 @@ set(ehpc_public_header_model
 	include/alibabacloud/ehpc/model/DescribeNFSClientStatusResult.h
 	include/alibabacloud/ehpc/model/DescribePriceRequest.h
 	include/alibabacloud/ehpc/model/DescribePriceResult.h
+	include/alibabacloud/ehpc/model/EcdDeleteDesktopsRequest.h
+	include/alibabacloud/ehpc/model/EcdDeleteDesktopsResult.h
 	include/alibabacloud/ehpc/model/EditJobTemplateRequest.h
 	include/alibabacloud/ehpc/model/EditJobTemplateResult.h
 	include/alibabacloud/ehpc/model/GetAccountingReportRequest.h
@@ -264,6 +268,8 @@ set(ehpc_src
 	src/EHPCClient.cc
 	src/model/AddContainerAppRequest.cc
 	src/model/AddContainerAppResult.cc
+	src/model/AddExistedNodesRequest.cc
+	src/model/AddExistedNodesResult.cc
 	src/model/AddLocalNodesRequest.cc
 	src/model/AddLocalNodesResult.cc
 	src/model/AddNodesRequest.cc
@@ -340,6 +346,8 @@ set(ehpc_src
 	src/model/DescribeNFSClientStatusResult.cc
 	src/model/DescribePriceRequest.cc
 	src/model/DescribePriceResult.cc
+	src/model/EcdDeleteDesktopsRequest.cc
+	src/model/EcdDeleteDesktopsResult.cc
 	src/model/EditJobTemplateRequest.cc
 	src/model/EditJobTemplateResult.cc
 	src/model/GetAccountingReportRequest.cc

ehpc/include/alibabacloud/ehpc/EHPCClient.h

@@ -24,6 +24,8 @@
 #include "EHPCExport.h"
 #include "model/AddContainerAppRequest.h"
 #include "model/AddContainerAppResult.h"
+#include "model/AddExistedNodesRequest.h"
+#include "model/AddExistedNodesResult.h"
 #include "model/AddLocalNodesRequest.h"
 #include "model/AddLocalNodesResult.h"
 #include "model/AddNodesRequest.h"
@@ -100,6 +102,8 @@
 #include "model/DescribeNFSClientStatusResult.h"
 #include "model/DescribePriceRequest.h"
 #include "model/DescribePriceResult.h"
+#include "model/EcdDeleteDesktopsRequest.h"
+#include "model/EcdDeleteDesktopsResult.h"
 #include "model/EditJobTemplateRequest.h"
 #include "model/EditJobTemplateResult.h"
 #include "model/GetAccountingReportRequest.h"
@@ -272,6 +276,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddContainerAppResult> AddContainerAppOutcome;
 			typedef std::future<AddContainerAppOutcome> AddContainerAppOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::AddContainerAppRequest&, const AddContainerAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddContainerAppAsyncHandler;
+			typedef Outcome<Error, Model::AddExistedNodesResult> AddExistedNodesOutcome;
+			typedef std::future<AddExistedNodesOutcome> AddExistedNodesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::AddExistedNodesRequest&, const AddExistedNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddExistedNodesAsyncHandler;
 			typedef Outcome<Error, Model::AddLocalNodesResult> AddLocalNodesOutcome;
 			typedef std::future<AddLocalNodesOutcome> AddLocalNodesOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::AddLocalNodesRequest&, const AddLocalNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLocalNodesAsyncHandler;
@@ -386,6 +393,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribePriceResult> DescribePriceOutcome;
 			typedef std::future<DescribePriceOutcome> DescribePriceOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::DescribePriceRequest&, const DescribePriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePriceAsyncHandler;
+			typedef Outcome<Error, Model::EcdDeleteDesktopsResult> EcdDeleteDesktopsOutcome;
+			typedef std::future<EcdDeleteDesktopsOutcome> EcdDeleteDesktopsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::EcdDeleteDesktopsRequest&, const EcdDeleteDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EcdDeleteDesktopsAsyncHandler;
 			typedef Outcome<Error, Model::EditJobTemplateResult> EditJobTemplateOutcome;
 			typedef std::future<EditJobTemplateOutcome> EditJobTemplateOutcomeCallable;
 			typedef std::function<void(const EHPCClient*, const Model::EditJobTemplateRequest&, const EditJobTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EditJobTemplateAsyncHandler;
@@ -634,6 +644,9 @@ namespace AlibabaCloud
 			AddContainerAppOutcome addContainerApp(const Model::AddContainerAppRequest &request)const;
 			void addContainerAppAsync(const Model::AddContainerAppRequest& request, const AddContainerAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddContainerAppOutcomeCallable addContainerAppCallable(const Model::AddContainerAppRequest& request) const;
+			AddExistedNodesOutcome addExistedNodes(const Model::AddExistedNodesRequest &request)const;
+			void addExistedNodesAsync(const Model::AddExistedNodesRequest& request, const AddExistedNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddExistedNodesOutcomeCallable addExistedNodesCallable(const Model::AddExistedNodesRequest& request) const;
 			AddLocalNodesOutcome addLocalNodes(const Model::AddLocalNodesRequest &request)const;
 			void addLocalNodesAsync(const Model::AddLocalNodesRequest& request, const AddLocalNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddLocalNodesOutcomeCallable addLocalNodesCallable(const Model::AddLocalNodesRequest& request) const;
@@ -748,6 +761,9 @@ namespace AlibabaCloud
 			DescribePriceOutcome describePrice(const Model::DescribePriceRequest &request)const;
 			void describePriceAsync(const Model::DescribePriceRequest& request, const DescribePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribePriceOutcomeCallable describePriceCallable(const Model::DescribePriceRequest& request) const;
+			EcdDeleteDesktopsOutcome ecdDeleteDesktops(const Model::EcdDeleteDesktopsRequest &request)const;
+			void ecdDeleteDesktopsAsync(const Model::EcdDeleteDesktopsRequest& request, const EcdDeleteDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EcdDeleteDesktopsOutcomeCallable ecdDeleteDesktopsCallable(const Model::EcdDeleteDesktopsRequest& request) const;
 			EditJobTemplateOutcome editJobTemplate(const Model::EditJobTemplateRequest &request)const;
 			void editJobTemplateAsync(const Model::EditJobTemplateRequest& request, const EditJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EditJobTemplateOutcomeCallable editJobTemplateCallable(const Model::EditJobTemplateRequest& request) const;

ehpc/include/alibabacloud/ehpc/model/AddExistedNodesRequest.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT AddExistedNodesRequest : public RpcServiceRequest
+			{
+			public:
+				struct Instance
+				{
+					std::string id;
+				};
+
+			public:
+				AddExistedNodesRequest();
+				~AddExistedNodesRequest();
+
+				std::string getImageId()const;
+				void setImageId(const std::string& imageId);
+				std::vector<Instance> getInstance()const;
+				void setInstance(const std::vector<Instance>& instance);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getJobQueue()const;
+				void setJobQueue(const std::string& jobQueue);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getImageOwnerAlias()const;
+				void setImageOwnerAlias(const std::string& imageOwnerAlias);
+
+            private:
+				std::string imageId_;
+				std::vector<Instance> instance_;
+				std::string clientToken_;
+				std::string clusterId_;
+				std::string jobQueue_;
+				std::string accessKeyId_;
+				std::string imageOwnerAlias_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddExistedNodesResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT AddExistedNodesResult : public ServiceResult
+			{
+			public:
+
+
+				AddExistedNodesResult();
+				explicit AddExistedNodesResult(const std::string &payload);
+				~AddExistedNodesResult();
+				std::string getTaskId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/AddNodesRequest.h

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setImageOwnerAlias(const std::string& imageOwnerAlias);
 				std::string getSystemDiskType()const;
 				void setSystemDiskType(const std::string& systemDiskType);
+				int getMinCount()const;
+				void setMinCount(int minCount);
 				int getSystemDiskSize()const;
 				void setSystemDiskSize(int systemDiskSize);
 				std::string getInstanceType()const;
@@ -102,6 +104,7 @@ namespace AlibabaCloud
 				std::string accessKeyId_;
 				std::string imageOwnerAlias_;
 				std::string systemDiskType_;
+				int minCount_;
 				int systemDiskSize_;
 				std::string instanceType_;
 				std::string hostNamePrefix_;

ehpc/include/alibabacloud/ehpc/model/ApplyNodesRequest.h

@@ -59,6 +59,8 @@ namespace AlibabaCloud
 				void setInternetMaxBandWidthOut(int internetMaxBandWidthOut);
 				std::string getResourceAmountType()const;
 				void setResourceAmountType(const std::string& resourceAmountType);
+				bool getStrictResourceProvision()const;
+				void setStrictResourceProvision(bool strictResourceProvision);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getSystemDiskType()const;
@@ -101,6 +103,7 @@ namespace AlibabaCloud
 				bool allocatePublicAddress_;
 				int internetMaxBandWidthOut_;
 				std::string resourceAmountType_;
+				bool strictResourceProvision_;
 				std::string accessKeyId_;
 				std::string systemDiskType_;
 				int cores_;

ehpc/include/alibabacloud/ehpc/model/CreateClusterRequest.h

@@ -147,6 +147,8 @@ namespace AlibabaCloud
 				void setClientVersion(const std::string& clientVersion);
 				std::string getOsTag()const;
 				void setOsTag(const std::string& osTag);
+				bool getIsComputeEss()const;
+				void setIsComputeEss(bool isComputeEss);
 				std::vector<Application> getApplication()const;
 				void setApplication(const std::vector<Application>& application);
 				std::string getEcsChargeType()const;
@@ -208,6 +210,7 @@ namespace AlibabaCloud
 				std::string volumeProtocol_;
 				std::string clientVersion_;
 				std::string osTag_;
+				bool isComputeEss_;
 				std::vector<Application> application_;
 				std::string ecsChargeType_;
 				std::string inputFileUrl_;

ehpc/include/alibabacloud/ehpc/model/CreateHybridClusterRequest.h

@@ -55,6 +55,8 @@ namespace AlibabaCloud
 
 				std::string getKeyPairName()const;
 				void setKeyPairName(const std::string& keyPairName);
+				bool getMultiOs()const;
+				void setMultiOs(bool multiOs);
 				std::string getSecurityGroupName()const;
 				void setSecurityGroupName(const std::string& securityGroupName);
 				std::string getOnPremiseVolumeRemotePath()const;
@@ -128,6 +130,7 @@ namespace AlibabaCloud
 
             private:
 				std::string keyPairName_;
+				bool multiOs_;
 				std::string securityGroupName_;
 				std::string onPremiseVolumeRemotePath_;
 				std::string imageOwnerAlias_;

ehpc/include/alibabacloud/ehpc/model/CreateJobTemplateRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				std::string getStderrRedirectPath()const;
 				void setStderrRedirectPath(const std::string& stderrRedirectPath);
+				std::string getClockTime()const;
+				void setClockTime(const std::string& clockTime);
 				std::string getCommandLine()const;
 				void setCommandLine(const std::string& commandLine);
 				std::string getAccessKeyId()const;
@@ -45,6 +47,8 @@ namespace AlibabaCloud
 				void setArrayRequest(const std::string& arrayRequest);
 				std::string getPackagePath()const;
 				void setPackagePath(const std::string& packagePath);
+				std::string getMem()const;
+				void setMem(const std::string& mem);
 				std::string getStdoutRedirectPath()const;
 				void setStdoutRedirectPath(const std::string& stdoutRedirectPath);
 				std::string getVariables()const;
@@ -53,23 +57,40 @@ namespace AlibabaCloud
 				void setRunasUser(const std::string& runasUser);
 				bool getReRunable()const;
 				void setReRunable(bool reRunable);
+				int getThread()const;
+				void setThread(int thread);
 				int getPriority()const;
 				void setPriority(int priority);
+				int getGpu()const;
+				void setGpu(int gpu);
+				int getNode()const;
+				void setNode(int node);
+				int getTask()const;
+				void setTask(int task);
 				std::string getName()const;
 				void setName(const std::string& name);
+				std::string getQueue()const;
+				void setQueue(const std::string& queue);
 
             private:
 				std::string stderrRedirectPath_;
+				std::string clockTime_;
 				std::string commandLine_;
 				std::string accessKeyId_;
 				std::string arrayRequest_;
 				std::string packagePath_;
+				std::string mem_;
 				std::string stdoutRedirectPath_;
 				std::string variables_;
 				std::string runasUser_;
 				bool reRunable_;
+				int thread_;
 				int priority_;
+				int gpu_;
+				int node_;
+				int task_;
 				std::string name_;
+				std::string queue_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/DescribePriceRequest.h

@@ -38,6 +38,7 @@ namespace AlibabaCloud
 					std::string nodeType;
 					std::string systemDiskCategory;
 					std::string internetChargeType;
+					std::string systemDiskPerformanceLevel;
 					int systemDiskSize;
 					int internetMaxBandWidthOut;
 					std::string instanceType;

ehpc/include/alibabacloud/ehpc/model/EcdDeleteDesktopsRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_ECDDELETEDESKTOPSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ECDDELETEDESKTOPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT EcdDeleteDesktopsRequest : public RpcServiceRequest
+			{
+
+			public:
+				EcdDeleteDesktopsRequest();
+				~EcdDeleteDesktopsRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::vector<std::string> getDesktopId()const;
+				void setDesktopId(const std::vector<std::string>& desktopId);
+
+            private:
+				std::string accessKeyId_;
+				std::vector<std::string> desktopId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ECDDELETEDESKTOPSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/EcdDeleteDesktopsResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_ECDDELETEDESKTOPSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ECDDELETEDESKTOPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT EcdDeleteDesktopsResult : public ServiceResult
+			{
+			public:
+
+
+				EcdDeleteDesktopsResult();
+				explicit EcdDeleteDesktopsResult(const std::string &payload);
+				~EcdDeleteDesktopsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ECDDELETEDESKTOPSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/EditJobTemplateRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				std::string getStderrRedirectPath()const;
 				void setStderrRedirectPath(const std::string& stderrRedirectPath);
+				std::string getClockTime()const;
+				void setClockTime(const std::string& clockTime);
 				std::string getCommandLine()const;
 				void setCommandLine(const std::string& commandLine);
 				std::string getAccessKeyId()const;
@@ -45,6 +47,8 @@ namespace AlibabaCloud
 				void setArrayRequest(const std::string& arrayRequest);
 				std::string getPackagePath()const;
 				void setPackagePath(const std::string& packagePath);
+				std::string getMem()const;
+				void setMem(const std::string& mem);
 				std::string getStdoutRedirectPath()const;
 				void setStdoutRedirectPath(const std::string& stdoutRedirectPath);
 				std::string getVariables()const;
@@ -53,26 +57,43 @@ namespace AlibabaCloud
 				void setRunasUser(const std::string& runasUser);
 				bool getReRunable()const;
 				void setReRunable(bool reRunable);
+				int getThread()const;
+				void setThread(int thread);
 				std::string getTemplateId()const;
 				void setTemplateId(const std::string& templateId);
 				int getPriority()const;
 				void setPriority(int priority);
+				int getGpu()const;
+				void setGpu(int gpu);
+				int getNode()const;
+				void setNode(int node);
+				int getTask()const;
+				void setTask(int task);
 				std::string getName()const;
 				void setName(const std::string& name);
+				std::string getQueue()const;
+				void setQueue(const std::string& queue);
 
             private:
 				std::string stderrRedirectPath_;
+				std::string clockTime_;
 				std::string commandLine_;
 				std::string accessKeyId_;
 				std::string arrayRequest_;
 				std::string packagePath_;
+				std::string mem_;
 				std::string stdoutRedirectPath_;
 				std::string variables_;
 				std::string runasUser_;
 				bool reRunable_;
+				int thread_;
 				std::string templateId_;
 				int priority_;
+				int gpu_;
+				int node_;
+				int task_;
 				std::string name_;
+				std::string queue_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/ListClustersMetaResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string status;
 					std::string description;
+					bool isComputeEss;
 					std::string vpcId;
 					std::string deployMode;
 					std::string osTag;

ehpc/include/alibabacloud/ehpc/model/ListClustersResult.h

@@ -78,6 +78,7 @@ namespace AlibabaCloud
 					std::string loginNodes;
 					Computes computes;
 					std::string status;
+					bool isComputeEss;
 					std::string zoneId;
 					std::string vSwitchId;
 					std::string createTime;

ehpc/include/alibabacloud/ehpc/model/ListCustomImagesRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				ListCustomImagesRequest();
 				~ListCustomImagesRequest();
 
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getImageOwnerAlias()const;
@@ -45,6 +47,7 @@ namespace AlibabaCloud
 				void setInstanceType(const std::string& instanceType);
 
             private:
+				std::string clusterId_;
 				std::string accessKeyId_;
 				std::string imageOwnerAlias_;
 				std::string baseOsTag_;

ehpc/include/alibabacloud/ehpc/model/ListJobTemplatesResult.h

@@ -34,17 +34,24 @@ namespace AlibabaCloud
 			public:
 				struct JobTemplates
 				{
+					int task;
+					int priority;
+					std::string stderrRedirectPath;
+					int node;
+					std::string clockTime;
+					std::string runasUser;
+					int gpu;
+					std::string name;
+					int thread;
 					std::string variables;
 					bool reRunable;
 					std::string commandLine;
-					int priority;
-					std::string stderrRedirectPath;
+					std::string mem;
 					std::string stdoutRedirectPath;
 					std::string id;
 					std::string arrayRequest;
-					std::string runasUser;
+					std::string queue;
 					std::string packagePath;
-					std::string name;
 				};
 
 

ehpc/include/alibabacloud/ehpc/model/ListNodesRequest.h

@@ -37,35 +37,41 @@ namespace AlibabaCloud
 
 				std::string getRole()const;
 				void setRole(const std::string& role);
-				std::string getClusterId()const;
-				void setClusterId(const std::string& clusterId);
 				int getPageNumber()const;
 				void setPageNumber(int pageNumber);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getHostName()const;
+				void setHostName(const std::string& hostName);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getHostNamePrefix()const;
+				void setHostNamePrefix(const std::string& hostNamePrefix);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getHostNameSuffix()const;
+				void setHostNameSuffix(const std::string& hostNameSuffix);
 				std::string getFilter()const;
 				void setFilter(const std::string& filter);
 				std::string getPrivateIpAddress()const;
 				void setPrivateIpAddress(const std::string& privateIpAddress);
 				std::string getSequence()const;
 				void setSequence(const std::string& sequence);
-				std::string getHostName()const;
-				void setHostName(const std::string& hostName);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
 				std::string getSortBy()const;
 				void setSortBy(const std::string& sortBy);
 
             private:
 				std::string role_;
-				std::string clusterId_;
 				int pageNumber_;
 				std::string accessKeyId_;
+				std::string hostName_;
+				int pageSize_;
+				std::string hostNamePrefix_;
+				std::string clusterId_;
+				std::string hostNameSuffix_;
 				std::string filter_;
 				std::string privateIpAddress_;
 				std::string sequence_;
-				std::string hostName_;
-				int pageSize_;
 				std::string sortBy_;
 
 			};

ehpc/include/alibabacloud/ehpc/model/ListQueuesResult.h

@@ -34,10 +34,21 @@ namespace AlibabaCloud
 			public:
 				struct QueueInfo
 				{
+					struct Instance
+					{
+						float spotPriceLimit;
+						std::string instanceType;
+					};
+					std::string hostNameSuffix;
 					std::string type;
+					std::vector<QueueInfo::Instance> spotInstanceTypes;
 					std::string resourceGroupId;
+					bool enableAutoGrow;
+					std::string imageId;
+					std::string hostNamePrefix;
 					std::string queueName;
-					std::string computeInstanceType;
+					std::string spotStrategy;
+					std::vector<std::string> computeInstanceType;
 				};
 
 

ehpc/src/EHPCClient.cc

@@ -87,6 +87,42 @@ EHPCClient::AddContainerAppOutcomeCallable EHPCClient::addContainerAppCallable(c
 	return task->get_future();
 }
 
+EHPCClient::AddExistedNodesOutcome EHPCClient::addExistedNodes(const AddExistedNodesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddExistedNodesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddExistedNodesOutcome(AddExistedNodesResult(outcome.result()));
+	else
+		return AddExistedNodesOutcome(outcome.error());
+}
+
+void EHPCClient::addExistedNodesAsync(const AddExistedNodesRequest& request, const AddExistedNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addExistedNodes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::AddExistedNodesOutcomeCallable EHPCClient::addExistedNodesCallable(const AddExistedNodesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddExistedNodesOutcome()>>(
+			[this, request]()
+			{
+			return this->addExistedNodes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::AddLocalNodesOutcome EHPCClient::addLocalNodes(const AddLocalNodesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1455,6 +1491,42 @@ EHPCClient::DescribePriceOutcomeCallable EHPCClient::describePriceCallable(const
 	return task->get_future();
 }
 
+EHPCClient::EcdDeleteDesktopsOutcome EHPCClient::ecdDeleteDesktops(const EcdDeleteDesktopsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EcdDeleteDesktopsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EcdDeleteDesktopsOutcome(EcdDeleteDesktopsResult(outcome.result()));
+	else
+		return EcdDeleteDesktopsOutcome(outcome.error());
+}
+
+void EHPCClient::ecdDeleteDesktopsAsync(const EcdDeleteDesktopsRequest& request, const EcdDeleteDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, ecdDeleteDesktops(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::EcdDeleteDesktopsOutcomeCallable EHPCClient::ecdDeleteDesktopsCallable(const EcdDeleteDesktopsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EcdDeleteDesktopsOutcome()>>(
+			[this, request]()
+			{
+			return this->ecdDeleteDesktops(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EHPCClient::EditJobTemplateOutcome EHPCClient::editJobTemplate(const EditJobTemplateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();