Support for addrp.

CHANGELOG

@@ -1,3 +1,77 @@
+2020-06-04 Version: 1.36.451
+- Support for addrp.
+
+2020-06-04 Version: 1.36.450
+- Supported Eni Trunking.
+
+2020-06-04 Version: 1.36.449
+- Update monitor related API.
+
+2020-06-04 Version: 1.36.448
+- Add SubmitMediaDNADeleteJob and ListMediaDNADeleteJob.
+- Modify GetMediaAuditResult interface, support ad logo and live result.
+- Modify GetMediaAuditResultTimeline interface, support ad logo and live result.
+
+2020-06-04 Version: 1.36.447
+- Update monitor related API.
+
+2020-06-04 Version: 1.36.446
+- Update monitor related API.
+
+2020-06-03 Version: 1.36.445
+- Describe describeAvailableResource.
+
+2020-06-03 Version: 1.36.444
+- Describe describeAvailableResource.
+
+2020-06-03 Version: 1.36.443
+- Generated 2019-01-01 for `Cassandra`.
+
+2020-06-03 Version: 1.36.442
+- DescribeCameraStatistics add filed.
+
+2020-06-02 Version: 1.36.441
+- Edit SearchTraces api.
+
+2020-05-28 Version: 1.36.440
+- Supported AndroidNotificationXiaomiChannel for Push and MassPush.
+
+2020-05-27 Version: 1.36.439
+- Added cn-heyuan endpoint url.
+- Added cn-wulanchabu endpoint url.
+
+2020-05-27 Version: 1.36.438
+- Add support for create hbaseue multizone instance.
+
+2020-05-26 Version: 1.36.437
+- Support DescribeAllEntity API.
+
+2020-05-26 Version: 1.36.436
+- Add smartcall service api.
+
+2020-05-26 Version: 1.36.435
+- Add smartcall service api.
+
+2020-05-26 Version: 1.36.434
+- Add monitor related API.
+
+2020-05-26 Version: 1.36.433
+- Add monitor related.
+
+2020-05-26 Version: 1.36.432
+- Add monitor related.
+
+2020-05-25 Version: 1.36.431
+- Add monitor related.
+
+2020-05-25 Version: 1.36.430
+- Add monitor related.
+
+2020-05-23 Version: 1.36.429
+- Generated 2015-01-01 for `R-kvstore`.
+- Add ModifyResourceGroup API.
+- DescribeInstanceAttribute return ResourceGroupId.
+
 2020-05-22 Version: 1.36.428
 - Add schedule crud api.
 

VERSION

@@ -1 +1 @@
-1.36.428
+1.36.451

address-purification/CMakeLists.txt

@@ -21,29 +21,53 @@ set(address-purification_public_header
 	include/alibabacloud/address-purification/Address_purificationExport.h )
 
 set(address-purification_public_header_model 
-	include/alibabacloud/address-purification/model/DescribeProductRequest.h
-	include/alibabacloud/address-purification/model/DescribeProductResult.h
-	include/alibabacloud/address-purification/model/GetAlgorithmResultRequest.h
-	include/alibabacloud/address-purification/model/GetAlgorithmResultResult.h
-	include/alibabacloud/address-purification/model/GetConsoleResultRequest.h
-	include/alibabacloud/address-purification/model/GetConsoleResultResult.h
-	include/alibabacloud/address-purification/model/GetReportRequest.h
-	include/alibabacloud/address-purification/model/GetReportResult.h
-	include/alibabacloud/address-purification/model/GetUserInfomationRequest.h
-	include/alibabacloud/address-purification/model/GetUserInfomationResult.h )
+	include/alibabacloud/address-purification/model/ClassifyPOIRequest.h
+	include/alibabacloud/address-purification/model/ClassifyPOIResult.h
+	include/alibabacloud/address-purification/model/CompleteAddressRequest.h
+	include/alibabacloud/address-purification/model/CompleteAddressResult.h
+	include/alibabacloud/address-purification/model/CorrectAddressRequest.h
+	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/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/GetAddressDivisionCodeRequest.h
+	include/alibabacloud/address-purification/model/GetAddressDivisionCodeResult.h
+	include/alibabacloud/address-purification/model/GetAddressSimilarityRequest.h
+	include/alibabacloud/address-purification/model/GetAddressSimilarityResult.h
+	include/alibabacloud/address-purification/model/GetZipcodeRequest.h
+	include/alibabacloud/address-purification/model/GetZipcodeResult.h
+	include/alibabacloud/address-purification/model/StructureAddressRequest.h
+	include/alibabacloud/address-purification/model/StructureAddressResult.h
+	include/alibabacloud/address-purification/model/UpdateProjectRequest.h
+	include/alibabacloud/address-purification/model/UpdateProjectResult.h )
 
 set(address-purification_src 
 	src/Address-purificationClient.cc
-	src/model/DescribeProductRequest.cc
-	src/model/DescribeProductResult.cc
-	src/model/GetAlgorithmResultRequest.cc
-	src/model/GetAlgorithmResultResult.cc
-	src/model/GetConsoleResultRequest.cc
-	src/model/GetConsoleResultResult.cc
-	src/model/GetReportRequest.cc
-	src/model/GetReportResult.cc
-	src/model/GetUserInfomationRequest.cc
-	src/model/GetUserInfomationResult.cc )
+	src/model/ClassifyPOIRequest.cc
+	src/model/ClassifyPOIResult.cc
+	src/model/CompleteAddressRequest.cc
+	src/model/CompleteAddressResult.cc
+	src/model/CorrectAddressRequest.cc
+	src/model/CorrectAddressResult.cc
+	src/model/ExtractAddressRequest.cc
+	src/model/ExtractAddressResult.cc
+	src/model/ExtractNameRequest.cc
+	src/model/ExtractNameResult.cc
+	src/model/ExtractPhoneRequest.cc
+	src/model/ExtractPhoneResult.cc
+	src/model/GetAddressDivisionCodeRequest.cc
+	src/model/GetAddressDivisionCodeResult.cc
+	src/model/GetAddressSimilarityRequest.cc
+	src/model/GetAddressSimilarityResult.cc
+	src/model/GetZipcodeRequest.cc
+	src/model/GetZipcodeResult.cc
+	src/model/StructureAddressRequest.cc
+	src/model/StructureAddressResult.cc
+	src/model/UpdateProjectRequest.cc
+	src/model/UpdateProjectResult.cc )
 
 add_library(address-purification ${LIB_TYPE}
 	${address-purification_public_header}

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

@@ -22,16 +22,28 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "Address_purificationExport.h"
-#include "model/DescribeProductRequest.h"
-#include "model/DescribeProductResult.h"
-#include "model/GetAlgorithmResultRequest.h"
-#include "model/GetAlgorithmResultResult.h"
-#include "model/GetConsoleResultRequest.h"
-#include "model/GetConsoleResultResult.h"
-#include "model/GetReportRequest.h"
-#include "model/GetReportResult.h"
-#include "model/GetUserInfomationRequest.h"
-#include "model/GetUserInfomationResult.h"
+#include "model/ClassifyPOIRequest.h"
+#include "model/ClassifyPOIResult.h"
+#include "model/CompleteAddressRequest.h"
+#include "model/CompleteAddressResult.h"
+#include "model/CorrectAddressRequest.h"
+#include "model/CorrectAddressResult.h"
+#include "model/ExtractAddressRequest.h"
+#include "model/ExtractAddressResult.h"
+#include "model/ExtractNameRequest.h"
+#include "model/ExtractNameResult.h"
+#include "model/ExtractPhoneRequest.h"
+#include "model/ExtractPhoneResult.h"
+#include "model/GetAddressDivisionCodeRequest.h"
+#include "model/GetAddressDivisionCodeResult.h"
+#include "model/GetAddressSimilarityRequest.h"
+#include "model/GetAddressSimilarityResult.h"
+#include "model/GetZipcodeRequest.h"
+#include "model/GetZipcodeResult.h"
+#include "model/StructureAddressRequest.h"
+#include "model/StructureAddressResult.h"
+#include "model/UpdateProjectRequest.h"
+#include "model/UpdateProjectResult.h"
 
 
 namespace AlibabaCloud
@@ -41,41 +53,77 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT Address_purificationClient : public RpcServiceClient
 		{
 		public:
-			typedef Outcome<Error, Model::DescribeProductResult> DescribeProductOutcome;
-			typedef std::future<DescribeProductOutcome> DescribeProductOutcomeCallable;
-			typedef std::function<void(const Address_purificationClient*, const Model::DescribeProductRequest&, const DescribeProductOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeProductAsyncHandler;
-			typedef Outcome<Error, Model::GetAlgorithmResultResult> GetAlgorithmResultOutcome;
-			typedef std::future<GetAlgorithmResultOutcome> GetAlgorithmResultOutcomeCallable;
-			typedef std::function<void(const Address_purificationClient*, const Model::GetAlgorithmResultRequest&, const GetAlgorithmResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAlgorithmResultAsyncHandler;
-			typedef Outcome<Error, Model::GetConsoleResultResult> GetConsoleResultOutcome;
-			typedef std::future<GetConsoleResultOutcome> GetConsoleResultOutcomeCallable;
-			typedef std::function<void(const Address_purificationClient*, const Model::GetConsoleResultRequest&, const GetConsoleResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetConsoleResultAsyncHandler;
-			typedef Outcome<Error, Model::GetReportResult> GetReportOutcome;
-			typedef std::future<GetReportOutcome> GetReportOutcomeCallable;
-			typedef std::function<void(const Address_purificationClient*, const Model::GetReportRequest&, const GetReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetReportAsyncHandler;
-			typedef Outcome<Error, Model::GetUserInfomationResult> GetUserInfomationOutcome;
-			typedef std::future<GetUserInfomationOutcome> GetUserInfomationOutcomeCallable;
-			typedef std::function<void(const Address_purificationClient*, const Model::GetUserInfomationRequest&, const GetUserInfomationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserInfomationAsyncHandler;
+			typedef Outcome<Error, Model::ClassifyPOIResult> ClassifyPOIOutcome;
+			typedef std::future<ClassifyPOIOutcome> ClassifyPOIOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::ClassifyPOIRequest&, const ClassifyPOIOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ClassifyPOIAsyncHandler;
+			typedef Outcome<Error, Model::CompleteAddressResult> CompleteAddressOutcome;
+			typedef std::future<CompleteAddressOutcome> CompleteAddressOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::CompleteAddressRequest&, const CompleteAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompleteAddressAsyncHandler;
+			typedef Outcome<Error, Model::CorrectAddressResult> CorrectAddressOutcome;
+			typedef std::future<CorrectAddressOutcome> CorrectAddressOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::CorrectAddressRequest&, const CorrectAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CorrectAddressAsyncHandler;
+			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::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::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::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::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::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::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;
 
 			Address_purificationClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			Address_purificationClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			Address_purificationClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~Address_purificationClient();
-			DescribeProductOutcome describeProduct(const Model::DescribeProductRequest &request)const;
-			void describeProductAsync(const Model::DescribeProductRequest& request, const DescribeProductAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeProductOutcomeCallable describeProductCallable(const Model::DescribeProductRequest& request) const;
-			GetAlgorithmResultOutcome getAlgorithmResult(const Model::GetAlgorithmResultRequest &request)const;
-			void getAlgorithmResultAsync(const Model::GetAlgorithmResultRequest& request, const GetAlgorithmResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetAlgorithmResultOutcomeCallable getAlgorithmResultCallable(const Model::GetAlgorithmResultRequest& request) const;
-			GetConsoleResultOutcome getConsoleResult(const Model::GetConsoleResultRequest &request)const;
-			void getConsoleResultAsync(const Model::GetConsoleResultRequest& request, const GetConsoleResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetConsoleResultOutcomeCallable getConsoleResultCallable(const Model::GetConsoleResultRequest& request) const;
-			GetReportOutcome getReport(const Model::GetReportRequest &request)const;
-			void getReportAsync(const Model::GetReportRequest& request, const GetReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetReportOutcomeCallable getReportCallable(const Model::GetReportRequest& request) const;
-			GetUserInfomationOutcome getUserInfomation(const Model::GetUserInfomationRequest &request)const;
-			void getUserInfomationAsync(const Model::GetUserInfomationRequest& request, const GetUserInfomationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			GetUserInfomationOutcomeCallable getUserInfomationCallable(const Model::GetUserInfomationRequest& request) const;
+			ClassifyPOIOutcome classifyPOI(const Model::ClassifyPOIRequest &request)const;
+			void classifyPOIAsync(const Model::ClassifyPOIRequest& request, const ClassifyPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ClassifyPOIOutcomeCallable classifyPOICallable(const Model::ClassifyPOIRequest& request) const;
+			CompleteAddressOutcome completeAddress(const Model::CompleteAddressRequest &request)const;
+			void completeAddressAsync(const Model::CompleteAddressRequest& request, const CompleteAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CompleteAddressOutcomeCallable completeAddressCallable(const Model::CompleteAddressRequest& request) const;
+			CorrectAddressOutcome correctAddress(const Model::CorrectAddressRequest &request)const;
+			void correctAddressAsync(const Model::CorrectAddressRequest& request, const CorrectAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CorrectAddressOutcomeCallable correctAddressCallable(const Model::CorrectAddressRequest& request) const;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

address-purification/include/alibabacloud/address-purification/model/ClassifyPOIRequest.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_CLASSIFYPOIREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIREQUEST_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 ClassifyPOIRequest : public RpcServiceRequest
+			{
+
+			public:
+				ClassifyPOIRequest();
+				~ClassifyPOIRequest();
+
+				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_CLASSIFYPOIREQUEST_H_

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTRESULT_H_
-#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTRESULT_H_
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,27 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetReportResult : public ServiceResult
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ClassifyPOIResult : public ServiceResult
 			{
 			public:
 
 
-				GetReportResult();
-				explicit GetReportResult(const std::string &payload);
-				~GetReportResult();
+				ClassifyPOIResult();
+				explicit ClassifyPOIResult(const std::string &payload);
+				~ClassifyPOIResult();
 				std::string getData()const;
-				std::string getErrMessage()const;
-				std::string getErrCode()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::string data_;
-				std::string errMessage_;
-				std::string errCode_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTRESULT_H_
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIRESULT_H_

address-purification/include/alibabacloud/address-purification/model/CompleteAddressRequest.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_COMPLETEADDRESSREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSREQUEST_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 CompleteAddressRequest : public RpcServiceRequest
+			{
+
+			public:
+				CompleteAddressRequest();
+				~CompleteAddressRequest();
+
+				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_COMPLETEADDRESSREQUEST_H_

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETUSERINFOMATIONRESULT_H_
-#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETUSERINFOMATIONRESULT_H_
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,27 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetUserInfomationResult : public ServiceResult
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT CompleteAddressResult : public ServiceResult
 			{
 			public:
 
 
-				GetUserInfomationResult();
-				explicit GetUserInfomationResult(const std::string &payload);
-				~GetUserInfomationResult();
+				CompleteAddressResult();
+				explicit CompleteAddressResult(const std::string &payload);
+				~CompleteAddressResult();
 				std::string getData()const;
-				std::string getErrMessage()const;
-				std::string getErrCode()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::string data_;
-				std::string errMessage_;
-				std::string errCode_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETUSERINFOMATIONRESULT_H_
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSRESULT_H_

address-purification/include/alibabacloud/address-purification/model/CorrectAddressRequest.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_CORRECTADDRESSREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSREQUEST_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 CorrectAddressRequest : public RpcServiceRequest
+			{
+
+			public:
+				CorrectAddressRequest();
+				~CorrectAddressRequest();
+
+				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_CORRECTADDRESSREQUEST_H_

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTRESULT_H_
-#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTRESULT_H_
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,29 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT DescribeProductResult : public ServiceResult
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT CorrectAddressResult : public ServiceResult
 			{
 			public:
 
 
-				DescribeProductResult();
-				explicit DescribeProductResult(const std::string &payload);
-				~DescribeProductResult();
+				CorrectAddressResult();
+				explicit CorrectAddressResult(const std::string &payload);
+				~CorrectAddressResult();
 				std::string getData()const;
-				std::string getErrMessage()const;
-				std::string getCode()const;
-				std::string getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::string data_;
-				std::string errMessage_;
-				std::string code_;
-				std::string success_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTRESULT_H_
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSRESULT_H_

address-purification/include/alibabacloud/address-purification/model/ExtractAddressRequest.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_EXTRACTADDRESSREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTADDRESSREQUEST_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 ExtractAddressRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExtractAddressRequest();
+				~ExtractAddressRequest();
+
+				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_EXTRACTADDRESSREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/ExtractAddressResult.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_EXTRACTADDRESSRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTADDRESSRESULT_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 ExtractAddressResult : public ServiceResult
+			{
+			public:
+
+
+				ExtractAddressResult();
+				explicit ExtractAddressResult(const std::string &payload);
+				~ExtractAddressResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTADDRESSRESULT_H_

address-purification/include/alibabacloud/address-purification/model/ExtractNameRequest.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_EXTRACTNAMEREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTNAMEREQUEST_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 ExtractNameRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExtractNameRequest();
+				~ExtractNameRequest();
+
+				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_EXTRACTNAMEREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/ExtractNameResult.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_EXTRACTNAMERESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTNAMERESULT_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 ExtractNameResult : public ServiceResult
+			{
+			public:
+
+
+				ExtractNameResult();
+				explicit ExtractNameResult(const std::string &payload);
+				~ExtractNameResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTNAMERESULT_H_

address-purification/include/alibabacloud/address-purification/model/ExtractPhoneRequest.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_EXTRACTPHONEREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTPHONEREQUEST_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 ExtractPhoneRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExtractPhoneRequest();
+				~ExtractPhoneRequest();
+
+				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_EXTRACTPHONEREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/ExtractPhoneResult.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_EXTRACTPHONERESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTPHONERESULT_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 ExtractPhoneResult : public ServiceResult
+			{
+			public:
+
+
+				ExtractPhoneResult();
+				explicit ExtractPhoneResult(const std::string &payload);
+				~ExtractPhoneResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTPHONERESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressDivisionCodeRequest.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_GETADDRESSDIVISIONCODEREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSDIVISIONCODEREQUEST_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 GetAddressDivisionCodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressDivisionCodeRequest();
+				~GetAddressDivisionCodeRequest();
+
+				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_GETADDRESSDIVISIONCODEREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressDivisionCodeResult.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_GETADDRESSDIVISIONCODERESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSDIVISIONCODERESULT_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 GetAddressDivisionCodeResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressDivisionCodeResult();
+				explicit GetAddressDivisionCodeResult(const std::string &payload);
+				~GetAddressDivisionCodeResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSDIVISIONCODERESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressSimilarityRequest.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_GETADDRESSSIMILARITYREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSIMILARITYREQUEST_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 GetAddressSimilarityRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressSimilarityRequest();
+				~GetAddressSimilarityRequest();
+
+				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_GETADDRESSSIMILARITYREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressSimilarityResult.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_GETADDRESSSIMILARITYRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSIMILARITYRESULT_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 GetAddressSimilarityResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressSimilarityResult();
+				explicit GetAddressSimilarityResult(const std::string &payload);
+				~GetAddressSimilarityResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSIMILARITYRESULT_H_

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

@@ -1,57 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTREQUEST_H_
-#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTREQUEST_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 GetConsoleResultRequest : public RpcServiceRequest
-			{
-
-			public:
-				GetConsoleResultRequest();
-				~GetConsoleResultRequest();
-
-				std::string getProductCode()const;
-				void setProductCode(const std::string& productCode);
-				std::string getApiCode()const;
-				void setApiCode(const std::string& apiCode);
-				std::string getCommodityCode()const;
-				void setCommodityCode(const std::string& commodityCode);
-				std::string getParameters()const;
-				void setParameters(const std::string& parameters);
-
-            private:
-				std::string productCode_;
-				std::string apiCode_;
-				std::string commodityCode_;
-				std::string parameters_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTREQUEST_H_

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

@@ -1,63 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTREQUEST_H_
-#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTREQUEST_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 GetReportRequest : public RpcServiceRequest
-			{
-
-			public:
-				GetReportRequest();
-				~GetReportRequest();
-
-				std::string getProductCode()const;
-				void setProductCode(const std::string& productCode);
-				std::string getReportType()const;
-				void setReportType(const std::string& reportType);
-				std::string getApiCode()const;
-				void setApiCode(const std::string& apiCode);
-				std::string getGranularity()const;
-				void setGranularity(const std::string& granularity);
-				std::string getCommodityCode()const;
-				void setCommodityCode(const std::string& commodityCode);
-				std::string getParameters()const;
-				void setParameters(const std::string& parameters);
-
-            private:
-				std::string productCode_;
-				std::string reportType_;
-				std::string apiCode_;
-				std::string granularity_;
-				std::string commodityCode_;
-				std::string parameters_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTREQUEST_H_

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETALGORITHMRESULTREQUEST_H_
-#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETALGORITHMRESULTREQUEST_H_
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODEREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODEREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,27 +28,36 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAlgorithmResultRequest : public RpcServiceRequest
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetZipcodeRequest : public RpcServiceRequest
 			{
 
 			public:
-				GetAlgorithmResultRequest();
-				~GetAlgorithmResultRequest();
+				GetZipcodeRequest();
+				~GetZipcodeRequest();
 
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
 				std::string getServiceCode()const;
 				void setServiceCode(const std::string& serviceCode);
-				std::string getApiCode()const;
-				void setApiCode(const std::string& apiCode);
-				std::string getParameters()const;
-				void setParameters(const std::string& parameters);
+				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 apiCode_;
-				std::string parameters_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETALGORITHMRESULTREQUEST_H_
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODEREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetZipcodeResult.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_GETZIPCODERESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODERESULT_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 GetZipcodeResult : public ServiceResult
+			{
+			public:
+
+
+				GetZipcodeResult();
+				explicit GetZipcodeResult(const std::string &payload);
+				~GetZipcodeResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODERESULT_H_

address-purification/include/alibabacloud/address-purification/model/StructureAddressRequest.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_STRUCTUREADDRESSREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSREQUEST_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 StructureAddressRequest : public RpcServiceRequest
+			{
+
+			public:
+				StructureAddressRequest();
+				~StructureAddressRequest();
+
+				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_STRUCTUREADDRESSREQUEST_H_

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTRESULT_H_
-#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTRESULT_H_
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,27 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetConsoleResultResult : public ServiceResult
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT StructureAddressResult : public ServiceResult
 			{
 			public:
 
 
-				GetConsoleResultResult();
-				explicit GetConsoleResultResult(const std::string &payload);
-				~GetConsoleResultResult();
+				StructureAddressResult();
+				explicit StructureAddressResult(const std::string &payload);
+				~StructureAddressResult();
 				std::string getData()const;
-				std::string getErrMessage()const;
-				std::string getErrCode()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::string data_;
-				std::string errMessage_;
-				std::string errCode_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTRESULT_H_
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSRESULT_H_

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

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTREQUEST_H_
-#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTREQUEST_H_
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,12 +28,12 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT DescribeProductRequest : public RpcServiceRequest
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT UpdateProjectRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeProductRequest();
-				~DescribeProductRequest();
+				UpdateProjectRequest();
+				~UpdateProjectRequest();
 
 				std::string getServiceCode()const;
 				void setServiceCode(const std::string& serviceCode);
@@ -48,4 +48,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTREQUEST_H_
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/UpdateProjectResult.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_UPDATEPROJECTRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTRESULT_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 UpdateProjectResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateProjectResult();
+				explicit UpdateProjectResult(const std::string &payload);
+				~UpdateProjectResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTRESULT_H_

address-purification/src/Address-purificationClient.cc

@@ -31,200 +31,416 @@ Address_purificationClient::Address_purificationClient(const Credentials &creden
 	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, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "addrp");
 }
 
 Address_purificationClient::Address_purificationClient(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, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "addrp");
 }
 
 Address_purificationClient::Address_purificationClient(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, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "addrp");
 }
 
 Address_purificationClient::~Address_purificationClient()
 {}
 
-Address_purificationClient::DescribeProductOutcome Address_purificationClient::describeProduct(const DescribeProductRequest &request) const
+Address_purificationClient::ClassifyPOIOutcome Address_purificationClient::classifyPOI(const ClassifyPOIRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeProductOutcome(endpointOutcome.error());
+		return ClassifyPOIOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeProductOutcome(DescribeProductResult(outcome.result()));
+		return ClassifyPOIOutcome(ClassifyPOIResult(outcome.result()));
 	else
-		return DescribeProductOutcome(outcome.error());
+		return ClassifyPOIOutcome(outcome.error());
 }
 
-void Address_purificationClient::describeProductAsync(const DescribeProductRequest& request, const DescribeProductAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Address_purificationClient::classifyPOIAsync(const ClassifyPOIRequest& request, const ClassifyPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeProduct(request), context);
+		handler(this, request, classifyPOI(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Address_purificationClient::DescribeProductOutcomeCallable Address_purificationClient::describeProductCallable(const DescribeProductRequest &request) const
+Address_purificationClient::ClassifyPOIOutcomeCallable Address_purificationClient::classifyPOICallable(const ClassifyPOIRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeProductOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<ClassifyPOIOutcome()>>(
 			[this, request]()
 			{
-			return this->describeProduct(request);
+			return this->classifyPOI(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-Address_purificationClient::GetAlgorithmResultOutcome Address_purificationClient::getAlgorithmResult(const GetAlgorithmResultRequest &request) const
+Address_purificationClient::CompleteAddressOutcome Address_purificationClient::completeAddress(const CompleteAddressRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return GetAlgorithmResultOutcome(endpointOutcome.error());
+		return CompleteAddressOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return GetAlgorithmResultOutcome(GetAlgorithmResultResult(outcome.result()));
+		return CompleteAddressOutcome(CompleteAddressResult(outcome.result()));
 	else
-		return GetAlgorithmResultOutcome(outcome.error());
+		return CompleteAddressOutcome(outcome.error());
 }
 
-void Address_purificationClient::getAlgorithmResultAsync(const GetAlgorithmResultRequest& request, const GetAlgorithmResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Address_purificationClient::completeAddressAsync(const CompleteAddressRequest& request, const CompleteAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, getAlgorithmResult(request), context);
+		handler(this, request, completeAddress(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Address_purificationClient::GetAlgorithmResultOutcomeCallable Address_purificationClient::getAlgorithmResultCallable(const GetAlgorithmResultRequest &request) const
+Address_purificationClient::CompleteAddressOutcomeCallable Address_purificationClient::completeAddressCallable(const CompleteAddressRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<GetAlgorithmResultOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CompleteAddressOutcome()>>(
 			[this, request]()
 			{
-			return this->getAlgorithmResult(request);
+			return this->completeAddress(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-Address_purificationClient::GetConsoleResultOutcome Address_purificationClient::getConsoleResult(const GetConsoleResultRequest &request) const
+Address_purificationClient::CorrectAddressOutcome Address_purificationClient::correctAddress(const CorrectAddressRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return GetConsoleResultOutcome(endpointOutcome.error());
+		return CorrectAddressOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return GetConsoleResultOutcome(GetConsoleResultResult(outcome.result()));
+		return CorrectAddressOutcome(CorrectAddressResult(outcome.result()));
 	else
-		return GetConsoleResultOutcome(outcome.error());
+		return CorrectAddressOutcome(outcome.error());
 }
 
-void Address_purificationClient::getConsoleResultAsync(const GetConsoleResultRequest& request, const GetConsoleResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Address_purificationClient::correctAddressAsync(const CorrectAddressRequest& request, const CorrectAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, getConsoleResult(request), context);
+		handler(this, request, correctAddress(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Address_purificationClient::GetConsoleResultOutcomeCallable Address_purificationClient::getConsoleResultCallable(const GetConsoleResultRequest &request) const
+Address_purificationClient::CorrectAddressOutcomeCallable Address_purificationClient::correctAddressCallable(const CorrectAddressRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<GetConsoleResultOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CorrectAddressOutcome()>>(
 			[this, request]()
 			{
-			return this->getConsoleResult(request);
+			return this->correctAddress(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-Address_purificationClient::GetReportOutcome Address_purificationClient::getReport(const GetReportRequest &request) const
+Address_purificationClient::ExtractAddressOutcome Address_purificationClient::extractAddress(const ExtractAddressRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return GetReportOutcome(endpointOutcome.error());
+		return ExtractAddressOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return GetReportOutcome(GetReportResult(outcome.result()));
+		return ExtractAddressOutcome(ExtractAddressResult(outcome.result()));
 	else
-		return GetReportOutcome(outcome.error());
+		return ExtractAddressOutcome(outcome.error());
 }
 
-void Address_purificationClient::getReportAsync(const GetReportRequest& request, const GetReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Address_purificationClient::extractAddressAsync(const ExtractAddressRequest& request, const ExtractAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, getReport(request), context);
+		handler(this, request, extractAddress(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Address_purificationClient::GetReportOutcomeCallable Address_purificationClient::getReportCallable(const GetReportRequest &request) const
+Address_purificationClient::ExtractAddressOutcomeCallable Address_purificationClient::extractAddressCallable(const ExtractAddressRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<GetReportOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<ExtractAddressOutcome()>>(
 			[this, request]()
 			{
-			return this->getReport(request);
+			return this->extractAddress(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-Address_purificationClient::GetUserInfomationOutcome Address_purificationClient::getUserInfomation(const GetUserInfomationRequest &request) const
+Address_purificationClient::ExtractNameOutcome Address_purificationClient::extractName(const ExtractNameRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return GetUserInfomationOutcome(endpointOutcome.error());
+		return ExtractNameOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return GetUserInfomationOutcome(GetUserInfomationResult(outcome.result()));
+		return ExtractNameOutcome(ExtractNameResult(outcome.result()));
 	else
-		return GetUserInfomationOutcome(outcome.error());
+		return ExtractNameOutcome(outcome.error());
 }
 
-void Address_purificationClient::getUserInfomationAsync(const GetUserInfomationRequest& request, const GetUserInfomationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Address_purificationClient::extractNameAsync(const ExtractNameRequest& request, const ExtractNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, getUserInfomation(request), context);
+		handler(this, request, extractName(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Address_purificationClient::GetUserInfomationOutcomeCallable Address_purificationClient::getUserInfomationCallable(const GetUserInfomationRequest &request) const
+Address_purificationClient::ExtractNameOutcomeCallable Address_purificationClient::extractNameCallable(const ExtractNameRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<GetUserInfomationOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<ExtractNameOutcome()>>(
 			[this, request]()
 			{
-			return this->getUserInfomation(request);
+			return this->extractName(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::ExtractPhoneOutcome Address_purificationClient::extractPhone(const ExtractPhoneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExtractPhoneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExtractPhoneOutcome(ExtractPhoneResult(outcome.result()));
+	else
+		return ExtractPhoneOutcome(outcome.error());
+}
+
+void Address_purificationClient::extractPhoneAsync(const ExtractPhoneRequest& request, const ExtractPhoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, extractPhone(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::ExtractPhoneOutcomeCallable Address_purificationClient::extractPhoneCallable(const ExtractPhoneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExtractPhoneOutcome()>>(
+			[this, request]()
+			{
+			return this->extractPhone(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::GetAddressDivisionCodeOutcome Address_purificationClient::getAddressDivisionCode(const GetAddressDivisionCodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressDivisionCodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressDivisionCodeOutcome(GetAddressDivisionCodeResult(outcome.result()));
+	else
+		return GetAddressDivisionCodeOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressDivisionCodeAsync(const GetAddressDivisionCodeRequest& request, const GetAddressDivisionCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressDivisionCode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressDivisionCodeOutcomeCallable Address_purificationClient::getAddressDivisionCodeCallable(const GetAddressDivisionCodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressDivisionCodeOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressDivisionCode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::GetAddressSimilarityOutcome Address_purificationClient::getAddressSimilarity(const GetAddressSimilarityRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressSimilarityOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressSimilarityOutcome(GetAddressSimilarityResult(outcome.result()));
+	else
+		return GetAddressSimilarityOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressSimilarityAsync(const GetAddressSimilarityRequest& request, const GetAddressSimilarityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressSimilarity(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressSimilarityOutcomeCallable Address_purificationClient::getAddressSimilarityCallable(const GetAddressSimilarityRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressSimilarityOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressSimilarity(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::GetZipcodeOutcome Address_purificationClient::getZipcode(const GetZipcodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetZipcodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetZipcodeOutcome(GetZipcodeResult(outcome.result()));
+	else
+		return GetZipcodeOutcome(outcome.error());
+}
+
+void Address_purificationClient::getZipcodeAsync(const GetZipcodeRequest& request, const GetZipcodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getZipcode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetZipcodeOutcomeCallable Address_purificationClient::getZipcodeCallable(const GetZipcodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetZipcodeOutcome()>>(
+			[this, request]()
+			{
+			return this->getZipcode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::StructureAddressOutcome Address_purificationClient::structureAddress(const StructureAddressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StructureAddressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StructureAddressOutcome(StructureAddressResult(outcome.result()));
+	else
+		return StructureAddressOutcome(outcome.error());
+}
+
+void Address_purificationClient::structureAddressAsync(const StructureAddressRequest& request, const StructureAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, structureAddress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::StructureAddressOutcomeCallable Address_purificationClient::structureAddressCallable(const StructureAddressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StructureAddressOutcome()>>(
+			[this, request]()
+			{
+			return this->structureAddress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::UpdateProjectOutcome Address_purificationClient::updateProject(const UpdateProjectRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateProjectOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateProjectOutcome(UpdateProjectResult(outcome.result()));
+	else
+		return UpdateProjectOutcome(outcome.error());
+}
+
+void Address_purificationClient::updateProjectAsync(const UpdateProjectRequest& request, const UpdateProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateProject(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::UpdateProjectOutcomeCallable Address_purificationClient::updateProjectCallable(const UpdateProjectRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateProjectOutcome()>>(
+			[this, request]()
+			{
+			return this->updateProject(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

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

address-purification/src/model/ClassifyPOIResult.cc

@@ -14,52 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/address-purification/model/GetUserInfomationResult.h>
+#include <alibabacloud/address-purification/model/ClassifyPOIResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Address_purification;
 using namespace AlibabaCloud::Address_purification::Model;
 
-GetUserInfomationResult::GetUserInfomationResult() :
+ClassifyPOIResult::ClassifyPOIResult() :
 	ServiceResult()
 {}
 
-GetUserInfomationResult::GetUserInfomationResult(const std::string &payload) :
+ClassifyPOIResult::ClassifyPOIResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-GetUserInfomationResult::~GetUserInfomationResult()
+ClassifyPOIResult::~ClassifyPOIResult()
 {}
 
-void GetUserInfomationResult::parse(const std::string &payload)
+void ClassifyPOIResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["ErrCode"].isNull())
-		errCode_ = value["ErrCode"].asString();
-	if(!value["ErrMessage"].isNull())
-		errMessage_ = value["ErrMessage"].asString();
 	if(!value["Data"].isNull())
 		data_ = value["Data"].asString();
 
 }
 
-std::string GetUserInfomationResult::getData()const
+std::string ClassifyPOIResult::getData()const
 {
 	return data_;
 }
 
-std::string GetUserInfomationResult::getErrMessage()const
-{
-	return errMessage_;
-}
-
-std::string GetUserInfomationResult::getErrCode()const
-{
-	return errCode_;
-}
-

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

address-purification/src/model/CompleteAddressResult.cc

@@ -14,59 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/address-purification/model/DescribeProductResult.h>
+#include <alibabacloud/address-purification/model/CompleteAddressResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Address_purification;
 using namespace AlibabaCloud::Address_purification::Model;
 
-DescribeProductResult::DescribeProductResult() :
+CompleteAddressResult::CompleteAddressResult() :
 	ServiceResult()
 {}
 
-DescribeProductResult::DescribeProductResult(const std::string &payload) :
+CompleteAddressResult::CompleteAddressResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DescribeProductResult::~DescribeProductResult()
+CompleteAddressResult::~CompleteAddressResult()
 {}
 
-void DescribeProductResult::parse(const std::string &payload)
+void CompleteAddressResult::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();
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["ErrMessage"].isNull())
-		errMessage_ = value["ErrMessage"].asString();
 	if(!value["Data"].isNull())
 		data_ = value["Data"].asString();
 
 }
 
-std::string DescribeProductResult::getData()const
+std::string CompleteAddressResult::getData()const
 {
 	return data_;
 }
 
-std::string DescribeProductResult::getErrMessage()const
-{
-	return errMessage_;
-}
-
-std::string DescribeProductResult::getCode()const
-{
-	return code_;
-}
-
-std::string DescribeProductResult::getSuccess()const
-{
-	return success_;
-}
-

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

address-purification/src/model/CorrectAddressResult.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/CorrectAddressResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
+
+CorrectAddressResult::CorrectAddressResult() :
+	ServiceResult()
+{}
+
+CorrectAddressResult::CorrectAddressResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CorrectAddressResult::~CorrectAddressResult()
+{}
+
+void CorrectAddressResult::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 CorrectAddressResult::getData()const
+{
+	return data_;
+}
+

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

address-purification/src/model/ExtractAddressResult.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/ExtractAddressResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
+
+ExtractAddressResult::ExtractAddressResult() :
+	ServiceResult()
+{}
+
+ExtractAddressResult::ExtractAddressResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ExtractAddressResult::~ExtractAddressResult()
+{}
+
+void ExtractAddressResult::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 ExtractAddressResult::getData()const
+{
+	return data_;
+}
+

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

address-purification/src/model/ExtractNameResult.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/ExtractNameResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
+
+ExtractNameResult::ExtractNameResult() :
+	ServiceResult()
+{}
+
+ExtractNameResult::ExtractNameResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ExtractNameResult::~ExtractNameResult()
+{}
+
+void ExtractNameResult::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 ExtractNameResult::getData()const
+{
+	return data_;
+}
+

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

address-purification/src/model/ExtractPhoneResult.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/ExtractPhoneResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
+
+ExtractPhoneResult::ExtractPhoneResult() :
+	ServiceResult()
+{}
+
+ExtractPhoneResult::ExtractPhoneResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ExtractPhoneResult::~ExtractPhoneResult()
+{}
+
+void ExtractPhoneResult::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 ExtractPhoneResult::getData()const
+{
+	return data_;
+}
+

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

address-purification/src/model/GetAddressDivisionCodeResult.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/GetAddressDivisionCodeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
+
+GetAddressDivisionCodeResult::GetAddressDivisionCodeResult() :
+	ServiceResult()
+{}
+
+GetAddressDivisionCodeResult::GetAddressDivisionCodeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAddressDivisionCodeResult::~GetAddressDivisionCodeResult()
+{}
+
+void GetAddressDivisionCodeResult::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 GetAddressDivisionCodeResult::getData()const
+{
+	return data_;
+}
+

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

address-purification/src/model/GetAddressSimilarityResult.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/GetAddressSimilarityResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
+
+GetAddressSimilarityResult::GetAddressSimilarityResult() :
+	ServiceResult()
+{}
+
+GetAddressSimilarityResult::GetAddressSimilarityResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAddressSimilarityResult::~GetAddressSimilarityResult()
+{}
+
+void GetAddressSimilarityResult::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 GetAddressSimilarityResult::getData()const
+{
+	return data_;
+}
+

address-purification/src/model/GetAlgorithmResultRequest.cc

@@ -1,62 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/address-purification/model/GetAlgorithmResultRequest.h>
-
-using AlibabaCloud::Address_purification::Model::GetAlgorithmResultRequest;
-
-GetAlgorithmResultRequest::GetAlgorithmResultRequest() :
-	RpcServiceRequest("address-purification", "2019-11-18", "GetAlgorithmResult")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-GetAlgorithmResultRequest::~GetAlgorithmResultRequest()
-{}
-
-std::string GetAlgorithmResultRequest::getServiceCode()const
-{
-	return serviceCode_;
-}
-
-void GetAlgorithmResultRequest::setServiceCode(const std::string& serviceCode)
-{
-	serviceCode_ = serviceCode;
-	setBodyParameter("ServiceCode", serviceCode);
-}
-
-std::string GetAlgorithmResultRequest::getApiCode()const
-{
-	return apiCode_;
-}
-
-void GetAlgorithmResultRequest::setApiCode(const std::string& apiCode)
-{
-	apiCode_ = apiCode;
-	setBodyParameter("ApiCode", apiCode);
-}
-
-std::string GetAlgorithmResultRequest::getParameters()const
-{
-	return parameters_;
-}
-
-void GetAlgorithmResultRequest::setParameters(const std::string& parameters)
-{
-	parameters_ = parameters;
-	setBodyParameter("Parameters", parameters);
-}
-

address-purification/src/model/GetConsoleResultRequest.cc

@@ -1,73 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/address-purification/model/GetConsoleResultRequest.h>
-
-using AlibabaCloud::Address_purification::Model::GetConsoleResultRequest;
-
-GetConsoleResultRequest::GetConsoleResultRequest() :
-	RpcServiceRequest("address-purification", "2019-11-18", "GetConsoleResult")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-GetConsoleResultRequest::~GetConsoleResultRequest()
-{}
-
-std::string GetConsoleResultRequest::getProductCode()const
-{
-	return productCode_;
-}
-
-void GetConsoleResultRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setBodyParameter("ProductCode", productCode);
-}
-
-std::string GetConsoleResultRequest::getApiCode()const
-{
-	return apiCode_;
-}
-
-void GetConsoleResultRequest::setApiCode(const std::string& apiCode)
-{
-	apiCode_ = apiCode;
-	setBodyParameter("ApiCode", apiCode);
-}
-
-std::string GetConsoleResultRequest::getCommodityCode()const
-{
-	return commodityCode_;
-}
-
-void GetConsoleResultRequest::setCommodityCode(const std::string& commodityCode)
-{
-	commodityCode_ = commodityCode;
-	setBodyParameter("CommodityCode", commodityCode);
-}
-
-std::string GetConsoleResultRequest::getParameters()const
-{
-	return parameters_;
-}
-
-void GetConsoleResultRequest::setParameters(const std::string& parameters)
-{
-	parameters_ = parameters;
-	setBodyParameter("Parameters", parameters);
-}
-

address-purification/src/model/GetReportRequest.cc

@@ -1,95 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/address-purification/model/GetReportRequest.h>
-
-using AlibabaCloud::Address_purification::Model::GetReportRequest;
-
-GetReportRequest::GetReportRequest() :
-	RpcServiceRequest("address-purification", "2019-11-18", "GetReport")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-GetReportRequest::~GetReportRequest()
-{}
-
-std::string GetReportRequest::getProductCode()const
-{
-	return productCode_;
-}
-
-void GetReportRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setBodyParameter("ProductCode", productCode);
-}
-
-std::string GetReportRequest::getReportType()const
-{
-	return reportType_;
-}
-
-void GetReportRequest::setReportType(const std::string& reportType)
-{
-	reportType_ = reportType;
-	setBodyParameter("ReportType", reportType);
-}
-
-std::string GetReportRequest::getApiCode()const
-{
-	return apiCode_;
-}
-
-void GetReportRequest::setApiCode(const std::string& apiCode)
-{
-	apiCode_ = apiCode;
-	setBodyParameter("ApiCode", apiCode);
-}
-
-std::string GetReportRequest::getGranularity()const
-{
-	return granularity_;
-}
-
-void GetReportRequest::setGranularity(const std::string& granularity)
-{
-	granularity_ = granularity;
-	setBodyParameter("Granularity", granularity);
-}
-
-std::string GetReportRequest::getCommodityCode()const
-{
-	return commodityCode_;
-}
-
-void GetReportRequest::setCommodityCode(const std::string& commodityCode)
-{
-	commodityCode_ = commodityCode;
-	setBodyParameter("CommodityCode", commodityCode);
-}
-
-std::string GetReportRequest::getParameters()const
-{
-	return parameters_;
-}
-
-void GetReportRequest::setParameters(const std::string& parameters)
-{
-	parameters_ = parameters;
-	setBodyParameter("Parameters", parameters);
-}
-

address-purification/src/model/GetUserInfomationRequest.cc

@@ -1,51 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/address-purification/model/GetUserInfomationRequest.h>
-
-using AlibabaCloud::Address_purification::Model::GetUserInfomationRequest;
-
-GetUserInfomationRequest::GetUserInfomationRequest() :
-	RpcServiceRequest("address-purification", "2019-11-18", "GetUserInfomation")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-GetUserInfomationRequest::~GetUserInfomationRequest()
-{}
-
-std::string GetUserInfomationRequest::getProductCode()const
-{
-	return productCode_;
-}
-
-void GetUserInfomationRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setBodyParameter("ProductCode", productCode);
-}
-
-std::string GetUserInfomationRequest::getParameters()const
-{
-	return parameters_;
-}
-
-void GetUserInfomationRequest::setParameters(const std::string& parameters)
-{
-	parameters_ = parameters;
-	setBodyParameter("Parameters", parameters);
-}
-

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

address-purification/src/model/GetZipcodeResult.cc

@@ -14,52 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/address-purification/model/GetReportResult.h>
+#include <alibabacloud/address-purification/model/GetZipcodeResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Address_purification;
 using namespace AlibabaCloud::Address_purification::Model;
 
-GetReportResult::GetReportResult() :
+GetZipcodeResult::GetZipcodeResult() :
 	ServiceResult()
 {}
 
-GetReportResult::GetReportResult(const std::string &payload) :
+GetZipcodeResult::GetZipcodeResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-GetReportResult::~GetReportResult()
+GetZipcodeResult::~GetZipcodeResult()
 {}
 
-void GetReportResult::parse(const std::string &payload)
+void GetZipcodeResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["ErrCode"].isNull())
-		errCode_ = value["ErrCode"].asString();
-	if(!value["ErrMessage"].isNull())
-		errMessage_ = value["ErrMessage"].asString();
 	if(!value["Data"].isNull())
 		data_ = value["Data"].asString();
 
 }
 
-std::string GetReportResult::getData()const
+std::string GetZipcodeResult::getData()const
 {
 	return data_;
 }
 
-std::string GetReportResult::getErrMessage()const
-{
-	return errMessage_;
-}
-
-std::string GetReportResult::getErrCode()const
-{
-	return errCode_;
-}
-

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

address-purification/src/model/StructureAddressResult.cc

@@ -14,52 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/address-purification/model/GetConsoleResultResult.h>
+#include <alibabacloud/address-purification/model/StructureAddressResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Address_purification;
 using namespace AlibabaCloud::Address_purification::Model;
 
-GetConsoleResultResult::GetConsoleResultResult() :
+StructureAddressResult::StructureAddressResult() :
 	ServiceResult()
 {}
 
-GetConsoleResultResult::GetConsoleResultResult(const std::string &payload) :
+StructureAddressResult::StructureAddressResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-GetConsoleResultResult::~GetConsoleResultResult()
+StructureAddressResult::~StructureAddressResult()
 {}
 
-void GetConsoleResultResult::parse(const std::string &payload)
+void StructureAddressResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["ErrCode"].isNull())
-		errCode_ = value["ErrCode"].asString();
-	if(!value["ErrMessage"].isNull())
-		errMessage_ = value["ErrMessage"].asString();
 	if(!value["Data"].isNull())
 		data_ = value["Data"].asString();
 
 }
 
-std::string GetConsoleResultResult::getData()const
+std::string StructureAddressResult::getData()const
 {
 	return data_;
 }
 
-std::string GetConsoleResultResult::getErrMessage()const
-{
-	return errMessage_;
-}
-
-std::string GetConsoleResultResult::getErrCode()const
-{
-	return errCode_;
-}
-

address-purification/src/model/UpdateProjectRequest.cc

@@ -14,36 +14,36 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/address-purification/model/DescribeProductRequest.h>
+#include <alibabacloud/address-purification/model/UpdateProjectRequest.h>
 
-using AlibabaCloud::Address_purification::Model::DescribeProductRequest;
+using AlibabaCloud::Address_purification::Model::UpdateProjectRequest;
 
-DescribeProductRequest::DescribeProductRequest() :
-	RpcServiceRequest("address-purification", "2019-11-18", "DescribeProduct")
+UpdateProjectRequest::UpdateProjectRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "UpdateProject")
 {
 	setMethod(HttpRequest::Method::Post);
 }
 
-DescribeProductRequest::~DescribeProductRequest()
+UpdateProjectRequest::~UpdateProjectRequest()
 {}
 
-std::string DescribeProductRequest::getServiceCode()const
+std::string UpdateProjectRequest::getServiceCode()const
 {
 	return serviceCode_;
 }
 
-void DescribeProductRequest::setServiceCode(const std::string& serviceCode)
+void UpdateProjectRequest::setServiceCode(const std::string& serviceCode)
 {
 	serviceCode_ = serviceCode;
 	setBodyParameter("ServiceCode", serviceCode);
 }
 
-std::string DescribeProductRequest::getParameters()const
+std::string UpdateProjectRequest::getParameters()const
 {
 	return parameters_;
 }
 
-void DescribeProductRequest::setParameters(const std::string& parameters)
+void UpdateProjectRequest::setParameters(const std::string& parameters)
 {
 	parameters_ = parameters;
 	setBodyParameter("Parameters", parameters);

address-purification/src/model/UpdateProjectResult.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/UpdateProjectResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
+
+UpdateProjectResult::UpdateProjectResult() :
+	ServiceResult()
+{}
+
+UpdateProjectResult::UpdateProjectResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateProjectResult::~UpdateProjectResult()
+{}
+
+void UpdateProjectResult::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 UpdateProjectResult::getData()const
+{
+	return data_;
+}
+

arms/include/alibabacloud/arms/model/SearchTracesRequest.h

@@ -31,6 +31,11 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ARMS_EXPORT SearchTracesRequest : public RpcServiceRequest
 			{
 			public:
+				struct ExclusionFilters
+				{
+					std::string value;
+					std::string key;
+				};
 				struct Tag
 				{
 					std::string value;
@@ -51,6 +56,8 @@ namespace AlibabaCloud
 				void setMinDuration(long minDuration);
 				std::string getServiceIp()const;
 				void setServiceIp(const std::string& serviceIp);
+				std::vector<ExclusionFilters> getExclusionFilters()const;
+				void setExclusionFilters(const std::vector<ExclusionFilters>& exclusionFilters);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				std::string getOperationName()const;
@@ -66,6 +73,7 @@ namespace AlibabaCloud
 				bool reverse_;
 				long minDuration_;
 				std::string serviceIp_;
+				std::vector<ExclusionFilters> exclusionFilters_;
 				std::string regionId_;
 				std::string operationName_;
 				std::string serviceName_;

arms/src/model/SearchTracesRequest.cc

@@ -82,6 +82,22 @@ void SearchTracesRequest::setServiceIp(const std::string& serviceIp)
 	setParameter("ServiceIp", serviceIp);
 }
 
+std::vector<SearchTracesRequest::ExclusionFilters> SearchTracesRequest::getExclusionFilters()const
+{
+	return exclusionFilters_;
+}
+
+void SearchTracesRequest::setExclusionFilters(const std::vector<ExclusionFilters>& exclusionFilters)
+{
+	exclusionFilters_ = exclusionFilters;
+	for(int dep1 = 0; dep1!= exclusionFilters.size(); dep1++) {
+		auto exclusionFiltersObj = exclusionFilters.at(dep1);
+		std::string exclusionFiltersObjStr = "ExclusionFilters." + std::to_string(dep1 + 1);
+		setParameter(exclusionFiltersObjStr + ".Value", exclusionFiltersObj.value);
+		setParameter(exclusionFiltersObjStr + ".Key", exclusionFiltersObj.key);
+	}
+}
+
 std::string SearchTracesRequest::getRegionId()const
 {
 	return regionId_;

cassandra/include/alibabacloud/cassandra/model/DescribeClusterResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 					};
 					std::string status;
 					std::string majorVersion;
+					int autoRenewPeriod;
 					std::string createdTime;
 					std::string clusterId;
 					std::string minorVersion;
@@ -48,6 +49,7 @@ namespace AlibabaCloud
 					std::string lockMode;
 					bool isLatestVersion;
 					std::string maintainEndTime;
+					bool autoRenewal;
 					int dataCenterCount;
 					std::string clusterName;
 					std::string expireTime;

cassandra/include/alibabacloud/cassandra/model/DescribeClustersResult.h

@@ -41,13 +41,15 @@ namespace AlibabaCloud
 					};
 					std::string status;
 					std::string majorVersion;
+					int autoRenewPeriod;
 					std::string createdTime;
 					std::string clusterId;
-					int dataCenterCount;
-					std::string clusterName;
 					std::string minorVersion;
 					std::string payType;
 					std::string lockMode;
+					bool autoRenewal;
+					int dataCenterCount;
+					std::string clusterName;
 					std::string expireTime;
 					std::vector<Cluster::Tag> tags;
 				};

cassandra/include/alibabacloud/cassandra/model/DescribeDataCenterResult.h

@@ -38,6 +38,7 @@ namespace AlibabaCloud
 				explicit DescribeDataCenterResult(const std::string &payload);
 				~DescribeDataCenterResult();
 				std::string getStatus()const;
+				int getAutoRenewPeriod()const;
 				std::string getDataCenterId()const;
 				std::string getCreatedTime()const;
 				std::string getCommodityInstance()const;
@@ -50,6 +51,7 @@ namespace AlibabaCloud
 				std::string getVswitchId()const;
 				std::string getDiskType()const;
 				std::string getVpcId()const;
+				bool getAutoRenewal()const;
 				int getDiskSize()const;
 				std::string getRegionId()const;
 				std::string getInstanceType()const;
@@ -59,6 +61,7 @@ namespace AlibabaCloud
 				void parse(const std::string &payload);
 			private:
 				std::string status_;
+				int autoRenewPeriod_;
 				std::string dataCenterId_;
 				std::string createdTime_;
 				std::string commodityInstance_;
@@ -71,6 +74,7 @@ namespace AlibabaCloud
 				std::string vswitchId_;
 				std::string diskType_;
 				std::string vpcId_;
+				bool autoRenewal_;
 				int diskSize_;
 				std::string regionId_;
 				std::string instanceType_;

cassandra/include/alibabacloud/cassandra/model/DescribeDataCentersResult.h

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct DataCenter
 				{
 					std::string status;
+					int autoRenewPeriod;
 					std::string dataCenterId;
 					std::string createdTime;
 					std::string commodityInstance;
@@ -47,6 +48,7 @@ namespace AlibabaCloud
 					std::string vswitchId;
 					std::string diskType;
 					std::string vpcId;
+					bool autoRenewal;
 					int diskSize;
 					std::string regionId;
 					std::string instanceType;

cassandra/include/alibabacloud/cassandra/model/RebootClusterRequest.h

@@ -35,10 +35,13 @@ namespace AlibabaCloud
 				RebootClusterRequest();
 				~RebootClusterRequest();
 
+				std::string getDataCenterId()const;
+				void setDataCenterId(const std::string& dataCenterId);
 				std::string getClusterId()const;
 				void setClusterId(const std::string& clusterId);
 
             private:
+				std::string dataCenterId_;
 				std::string clusterId_;
 
 			};

cassandra/src/model/DescribeClusterResult.cc

@@ -66,6 +66,10 @@ void DescribeClusterResult::parse(const std::string &payload)
 		cluster_.maintainEndTime = clusterNode["MaintainEndTime"].asString();
 	if(!clusterNode["LockMode"].isNull())
 		cluster_.lockMode = clusterNode["LockMode"].asString();
+	if(!clusterNode["AutoRenewal"].isNull())
+		cluster_.autoRenewal = clusterNode["AutoRenewal"].asString() == "true";
+	if(!clusterNode["AutoRenewPeriod"].isNull())
+		cluster_.autoRenewPeriod = std::stoi(clusterNode["AutoRenewPeriod"].asString());
 	auto allTagsNode = clusterNode["Tags"]["Tag"];
 	for (auto clusterNodeTagsTag : allTagsNode)
 	{

cassandra/src/model/DescribeClustersResult.cc

@@ -63,6 +63,10 @@ void DescribeClustersResult::parse(const std::string &payload)
 			clustersObject.dataCenterCount = std::stoi(valueClustersCluster["DataCenterCount"].asString());
 		if(!valueClustersCluster["LockMode"].isNull())
 			clustersObject.lockMode = valueClustersCluster["LockMode"].asString();
+		if(!valueClustersCluster["AutoRenewal"].isNull())
+			clustersObject.autoRenewal = valueClustersCluster["AutoRenewal"].asString() == "true";
+		if(!valueClustersCluster["AutoRenewPeriod"].isNull())
+			clustersObject.autoRenewPeriod = std::stoi(valueClustersCluster["AutoRenewPeriod"].asString());
 		auto allTagsNode = allClustersNode["Tags"]["Tag"];
 		for (auto allClustersNodeTagsTag : allTagsNode)
 		{

cassandra/src/model/DescribeDataCenterResult.cc

@@ -73,6 +73,10 @@ void DescribeDataCenterResult::parse(const std::string &payload)
 		expireTime_ = value["ExpireTime"].asString();
 	if(!value["LockMode"].isNull())
 		lockMode_ = value["LockMode"].asString();
+	if(!value["AutoRenewal"].isNull())
+		autoRenewal_ = value["AutoRenewal"].asString() == "true";
+	if(!value["AutoRenewPeriod"].isNull())
+		autoRenewPeriod_ = std::stoi(value["AutoRenewPeriod"].asString());
 
 }
 
@@ -81,6 +85,11 @@ std::string DescribeDataCenterResult::getStatus()const
 	return status_;
 }
 
+int DescribeDataCenterResult::getAutoRenewPeriod()const
+{
+	return autoRenewPeriod_;
+}
+
 std::string DescribeDataCenterResult::getDataCenterId()const
 {
 	return dataCenterId_;
@@ -141,6 +150,11 @@ std::string DescribeDataCenterResult::getVpcId()const
 	return vpcId_;
 }
 
+bool DescribeDataCenterResult::getAutoRenewal()const
+{
+	return autoRenewal_;
+}
+
 int DescribeDataCenterResult::getDiskSize()const
 {
 	return diskSize_;

cassandra/src/model/DescribeDataCentersResult.cc

@@ -77,6 +77,10 @@ void DescribeDataCentersResult::parse(const std::string &payload)
 			dataCentersObject.expireTime = valueDataCentersDataCenter["ExpireTime"].asString();
 		if(!valueDataCentersDataCenter["LockMode"].isNull())
 			dataCentersObject.lockMode = valueDataCentersDataCenter["LockMode"].asString();
+		if(!valueDataCentersDataCenter["AutoRenewal"].isNull())
+			dataCentersObject.autoRenewal = valueDataCentersDataCenter["AutoRenewal"].asString() == "true";
+		if(!valueDataCentersDataCenter["AutoRenewPeriod"].isNull())
+			dataCentersObject.autoRenewPeriod = std::stoi(valueDataCentersDataCenter["AutoRenewPeriod"].asString());
 		dataCenters_.push_back(dataCentersObject);
 	}
 

cassandra/src/model/RebootClusterRequest.cc

@@ -27,6 +27,17 @@ RebootClusterRequest::RebootClusterRequest() :
 RebootClusterRequest::~RebootClusterRequest()
 {}
 
+std::string RebootClusterRequest::getDataCenterId()const
+{
+	return dataCenterId_;
+}
+
+void RebootClusterRequest::setDataCenterId(const std::string& dataCenterId)
+{
+	dataCenterId_ = dataCenterId;
+	setParameter("DataCenterId", dataCenterId);
+}
+
 std::string RebootClusterRequest::getClusterId()const
 {
 	return clusterId_;

dds/include/alibabacloud/dds/model/DescribeTagsRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setRegionId(const std::string& regionId);
 				std::string getNextToken()const;
 				void setNextToken(const std::string& nextToken);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
@@ -51,16 +53,20 @@ namespace AlibabaCloud
 				void setOwnerId(long ownerId);
 				std::string getResourceType()const;
 				void setResourceType(const std::string& resourceType);
+				std::string getCategory()const;
+				void setCategory(const std::string& category);
 
             private:
 				long resourceOwnerId_;
 				std::string accessKeyId_;
 				std::string regionId_;
 				std::string nextToken_;
+				std::string product_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
 				std::string resourceType_;
+				std::string category_;
 
 			};
 		}

dds/src/model/DescribeTagsRequest.cc

@@ -71,6 +71,17 @@ void DescribeTagsRequest::setNextToken(const std::string& nextToken)
 	setParameter("NextToken", nextToken);
 }
 
+std::string DescribeTagsRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeTagsRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
 std::string DescribeTagsRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -115,3 +126,14 @@ void DescribeTagsRequest::setResourceType(const std::string& resourceType)
 	setParameter("ResourceType", resourceType);
 }
 
+std::string DescribeTagsRequest::getCategory()const
+{
+	return category_;
+}
+
+void DescribeTagsRequest::setCategory(const std::string& category)
+{
+	category_ = category;
+	setParameter("Category", category);
+}
+

ecs/CMakeLists.txt

@@ -293,6 +293,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/DescribeLimitationResult.h
 	include/alibabacloud/ecs/model/DescribeNatGatewaysRequest.h
 	include/alibabacloud/ecs/model/DescribeNatGatewaysResult.h
+	include/alibabacloud/ecs/model/DescribeNetworkInterfaceAttributeRequest.h
+	include/alibabacloud/ecs/model/DescribeNetworkInterfaceAttributeResult.h
 	include/alibabacloud/ecs/model/DescribeNetworkInterfacePermissionsRequest.h
 	include/alibabacloud/ecs/model/DescribeNetworkInterfacePermissionsResult.h
 	include/alibabacloud/ecs/model/DescribeNetworkInterfacesRequest.h
@@ -862,6 +864,8 @@ set(ecs_src
 	src/model/DescribeLimitationResult.cc
 	src/model/DescribeNatGatewaysRequest.cc
 	src/model/DescribeNatGatewaysResult.cc
+	src/model/DescribeNetworkInterfaceAttributeRequest.cc
+	src/model/DescribeNetworkInterfaceAttributeResult.cc
 	src/model/DescribeNetworkInterfacePermissionsRequest.cc
 	src/model/DescribeNetworkInterfacePermissionsResult.cc
 	src/model/DescribeNetworkInterfacesRequest.cc

ecs/include/alibabacloud/ecs/EcsClient.h

@@ -294,6 +294,8 @@
 #include "model/DescribeLimitationResult.h"
 #include "model/DescribeNatGatewaysRequest.h"
 #include "model/DescribeNatGatewaysResult.h"
+#include "model/DescribeNetworkInterfaceAttributeRequest.h"
+#include "model/DescribeNetworkInterfaceAttributeResult.h"
 #include "model/DescribeNetworkInterfacePermissionsRequest.h"
 #include "model/DescribeNetworkInterfacePermissionsResult.h"
 #include "model/DescribeNetworkInterfacesRequest.h"
@@ -1005,6 +1007,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeNatGatewaysResult> DescribeNatGatewaysOutcome;
 			typedef std::future<DescribeNatGatewaysOutcome> DescribeNatGatewaysOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeNatGatewaysRequest&, const DescribeNatGatewaysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNatGatewaysAsyncHandler;
+			typedef Outcome<Error, Model::DescribeNetworkInterfaceAttributeResult> DescribeNetworkInterfaceAttributeOutcome;
+			typedef std::future<DescribeNetworkInterfaceAttributeOutcome> DescribeNetworkInterfaceAttributeOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::DescribeNetworkInterfaceAttributeRequest&, const DescribeNetworkInterfaceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNetworkInterfaceAttributeAsyncHandler;
 			typedef Outcome<Error, Model::DescribeNetworkInterfacePermissionsResult> DescribeNetworkInterfacePermissionsOutcome;
 			typedef std::future<DescribeNetworkInterfacePermissionsOutcome> DescribeNetworkInterfacePermissionsOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeNetworkInterfacePermissionsRequest&, const DescribeNetworkInterfacePermissionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNetworkInterfacePermissionsAsyncHandler;
@@ -1859,6 +1864,9 @@ namespace AlibabaCloud
 			DescribeNatGatewaysOutcome describeNatGateways(const Model::DescribeNatGatewaysRequest &request)const;
 			void describeNatGatewaysAsync(const Model::DescribeNatGatewaysRequest& request, const DescribeNatGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeNatGatewaysOutcomeCallable describeNatGatewaysCallable(const Model::DescribeNatGatewaysRequest& request) const;
+			DescribeNetworkInterfaceAttributeOutcome describeNetworkInterfaceAttribute(const Model::DescribeNetworkInterfaceAttributeRequest &request)const;
+			void describeNetworkInterfaceAttributeAsync(const Model::DescribeNetworkInterfaceAttributeRequest& request, const DescribeNetworkInterfaceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeNetworkInterfaceAttributeOutcomeCallable describeNetworkInterfaceAttributeCallable(const Model::DescribeNetworkInterfaceAttributeRequest& request) const;
 			DescribeNetworkInterfacePermissionsOutcome describeNetworkInterfacePermissions(const Model::DescribeNetworkInterfacePermissionsRequest &request)const;
 			void describeNetworkInterfacePermissionsAsync(const Model::DescribeNetworkInterfacePermissionsRequest& request, const DescribeNetworkInterfacePermissionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeNetworkInterfacePermissionsOutcomeCallable describeNetworkInterfacePermissionsCallable(const Model::DescribeNetworkInterfacePermissionsRequest& request) const;

ecs/include/alibabacloud/ecs/model/AttachNetworkInterfaceRequest.h

@@ -39,6 +39,8 @@ namespace AlibabaCloud
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getTrunkNetworkInstanceId()const;
+				void setTrunkNetworkInstanceId(const std::string& trunkNetworkInstanceId);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
@@ -53,6 +55,7 @@ namespace AlibabaCloud
             private:
 				long resourceOwnerId_;
 				std::string regionId_;
+				std::string trunkNetworkInstanceId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;

ecs/include/alibabacloud/ecs/model/CreateAutoSnapshotPolicyRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				int getCopiedSnapshotsRetentionDays()const;
+				void setCopiedSnapshotsRetentionDays(int copiedSnapshotsRetentionDays);
 				std::string getTimePoints()const;
 				void setTimePoints(const std::string& timePoints);
 				std::string getRepeatWeekdays()const;
@@ -51,6 +53,8 @@ namespace AlibabaCloud
 				void setRegionId(const std::string& regionId);
 				std::vector<Tag> getTag()const;
 				void setTag(const std::vector<Tag>& tag);
+				bool getEnableCrossRegionCopy()const;
+				void setEnableCrossRegionCopy(bool enableCrossRegionCopy);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				long getOwnerId()const;
@@ -59,17 +63,22 @@ namespace AlibabaCloud
 				void setAutoSnapshotPolicyName(const std::string& autoSnapshotPolicyName);
 				int getRetentionDays()const;
 				void setRetentionDays(int retentionDays);
+				std::string getTargetCopyRegions()const;
+				void setTargetCopyRegions(const std::string& targetCopyRegions);
 
             private:
 				long resourceOwnerId_;
+				int copiedSnapshotsRetentionDays_;
 				std::string timePoints_;
 				std::string repeatWeekdays_;
 				std::string regionId_;
 				std::vector<Tag> tag_;
+				bool enableCrossRegionCopy_;
 				std::string resourceOwnerAccount_;
 				long ownerId_;
 				std::string autoSnapshotPolicyName_;
 				int retentionDays_;
+				std::string targetCopyRegions_;
 
 			};
 		}

ecs/include/alibabacloud/ecs/model/CreateNetworkInterfaceRequest.h

@@ -57,6 +57,8 @@ namespace AlibabaCloud
 				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
 				std::vector<Tag> getTag()const;
 				void setTag(const std::vector<Tag>& tag);
 				std::string getNetworkInterfaceName()const;
@@ -87,6 +89,7 @@ namespace AlibabaCloud
 				std::string businessType_;
 				std::string resourceGroupId_;
 				std::string regionId_;
+				std::string instanceType_;
 				std::vector<Tag> tag_;
 				std::string networkInterfaceName_;
 				bool visible_;

ecs/include/alibabacloud/ecs/model/DescribeAutoSnapshotPolicyExResult.h

@@ -42,14 +42,17 @@ namespace AlibabaCloud
 					std::string status;
 					std::string timePoints;
 					int volumeNums;
-					std::string creationTime;
 					std::string autoSnapshotPolicyId;
 					int retentionDays;
-					std::string regionId;
 					std::string repeatWeekdays;
+					int diskNums;
+					int copiedSnapshotsRetentionDays;
+					std::string targetCopyRegions;
+					bool enableCrossRegionCopy;
+					std::string creationTime;
+					std::string regionId;
 					std::string autoSnapshotPolicyName;
 					std::vector<AutoSnapshotPolicy::Tag> tags;
-					int diskNums;
 				};
 
 

ecs/include/alibabacloud/ecs/model/DescribeDisksFullStatusResult.h

@@ -53,6 +53,7 @@ namespace AlibabaCloud
 						};
 						EventType eventType;
 						std::string eventTime;
+						std::string impactLevel;
 						std::string eventId;
 						std::string eventEndTime;
 					};

ecs/include/alibabacloud/ecs/model/DescribeInstanceHistoryEventsRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setEventCycleStatus(const std::string& eventCycleStatus);
 				int getPageNumber()const;
 				void setPageNumber(int pageNumber);
+				std::string getImpactLevel()const;
+				void setImpactLevel(const std::string& impactLevel);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				int getPageSize()const;
@@ -75,6 +77,7 @@ namespace AlibabaCloud
 				long resourceOwnerId_;
 				std::string eventCycleStatus_;
 				int pageNumber_;
+				std::string impactLevel_;
 				std::string regionId_;
 				int pageSize_;
 				std::vector<std::string> instanceEventCycleStatus_;

ecs/include/alibabacloud/ecs/model/DescribeInstanceHistoryEventsResult.h

@@ -63,6 +63,7 @@ namespace AlibabaCloud
 					std::string eventPublishTime;
 					EventType eventType;
 					std::string instanceId;
+					std::string impactLevel;
 					ExtendedAttribute extendedAttribute;
 					std::string eventId;
 					std::string notBefore;

ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesResult.h

@@ -40,6 +40,8 @@ namespace AlibabaCloud
 					int cpuCoreCount;
 					long localStorageCapacity;
 					int totalEniQueueQuantity;
+					int eniTotalQuantity;
+					bool eniTrunkSupported;
 					std::string instanceTypeFamily;
 					long instancePpsRx;
 					int initialCredit;

ecs/include/alibabacloud/ecs/model/DescribeInstancesFullStatusResult.h

@@ -73,6 +73,7 @@ namespace AlibabaCloud
 						EventCycleStatus eventCycleStatus;
 						std::string eventPublishTime;
 						EventType eventType;
+						std::string impactLevel;
 						ExtendedAttribute extendedAttribute;
 						std::string eventId;
 						std::string notBefore;

ecs/include/alibabacloud/ecs/model/DescribeInvocationResultsRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setPageNumber(long pageNumber);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getContentEncoding()const;
+				void setContentEncoding(const std::string& contentEncoding);
 				long getPageSize()const;
 				void setPageSize(long pageSize);
 				std::string getInvokeId()const;
@@ -65,6 +67,7 @@ namespace AlibabaCloud
 				std::string commandId_;
 				long pageNumber_;
 				std::string regionId_;
+				std::string contentEncoding_;
 				long pageSize_;
 				std::string invokeId_;
 				std::string resourceOwnerAccount_;

ecs/include/alibabacloud/ecs/model/DescribeInvocationResultsResult.h

@@ -36,14 +36,20 @@ namespace AlibabaCloud
 				{
 					struct InvocationResult
 					{
+						int dropped;
+						std::string invocationStatus;
 						std::string instanceId;
-						std::string output;
 						long exitCode;
+						std::string errorInfo;
 						std::string startTime;
-						std::string commandId;
+						int repeats;
 						std::string invokeRecordStatus;
 						std::string finishedTime;
+						std::string output;
+						std::string commandId;
+						std::string errorCode;
 						std::string invokeId;
+						std::string stopTime;
 					};
 					std::vector<InvocationResult> invocationResults;
 					long totalCount;

ecs/include/alibabacloud/ecs/model/DescribeInvocationsResult.h

@@ -52,6 +52,7 @@ namespace AlibabaCloud
 						std::string stopTime;
 					};
 					std::string commandContent;
+					std::string invocationStatus;
 					std::string invokeStatus;
 					std::string parameters;
 					std::string commandType;

ecs/include/alibabacloud/ecs/model/DescribeNetworkInterfaceAttributeRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBENETWORKINTERFACEATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBENETWORKINTERFACEATTRIBUTEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT DescribeNetworkInterfaceAttributeRequest : public RpcServiceRequest
+			{
+			public:
+				struct Tag
+				{
+					std::string key;
+					std::string value;
+				};
+
+			public:
+				DescribeNetworkInterfaceAttributeRequest();
+				~DescribeNetworkInterfaceAttributeRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::vector<Tag> getTag()const;
+				void setTag(const std::vector<Tag>& tag);
+				std::string getAttribute()const;
+				void setAttribute(const std::string& attribute);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getNetworkInterfaceId()const;
+				void setNetworkInterfaceId(const std::string& networkInterfaceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string regionId_;
+				std::vector<Tag> tag_;
+				std::string attribute_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string networkInterfaceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBENETWORKINTERFACEATTRIBUTEREQUEST_H_

ecs/include/alibabacloud/ecs/model/DescribeNetworkInterfaceAttributeResult.h

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_ECS_MODEL_DESCRIBENETWORKINTERFACEATTRIBUTERESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBENETWORKINTERFACEATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT DescribeNetworkInterfaceAttributeResult : public ServiceResult
+			{
+			public:
+				struct AssociatedPublicIp
+				{
+					std::string publicIpAddress;
+					std::string allocationId;
+				};
+				struct Attachment
+				{
+					std::string instanceId;
+					int deviceIndex;
+					std::vector<std::string> memberNetworkInterfaceIds;
+					std::string trunkNetworkInterfaceId;
+				};
+				struct PrivateIpSet
+				{
+					struct AssociatedPublicIp1
+					{
+						std::string publicIpAddress;
+						std::string allocationId;
+					};
+					AssociatedPublicIp1 associatedPublicIp1;
+					std::string privateIpAddress;
+					bool primary;
+				};
+				struct Ipv6Set
+				{
+					std::string ipv6Address;
+				};
+				struct Tag
+				{
+					std::string tagKey;
+					std::string tagValue;
+				};
+
+
+				DescribeNetworkInterfaceAttributeResult();
+				explicit DescribeNetworkInterfaceAttributeResult(const std::string &payload);
+				~DescribeNetworkInterfaceAttributeResult();
+				std::string getStatus()const;
+				std::string getPrivateIpAddress()const;
+				std::string getDescription()const;
+				std::string getZoneId()const;
+				std::string getResourceGroupId()const;
+				bool getServiceManaged()const;
+				std::string getInstanceId()const;
+				std::string getVSwitchId()const;
+				std::string getNetworkInterfaceName()const;
+				Attachment getAttachment()const;
+				std::string getNetworkInterfaceId()const;
+				std::string getMacAddress()const;
+				std::vector<std::string> getSecurityGroupIds()const;
+				long getServiceID()const;
+				std::string getType()const;
+				std::vector<Ipv6Set> getIpv6Sets()const;
+				int getQueueNumber()const;
+				std::string getVpcId()const;
+				std::string getOwnerId()const;
+				AssociatedPublicIp getAssociatedPublicIp()const;
+				std::string getCreationTime()const;
+				std::vector<Tag> getTags()const;
+				std::vector<PrivateIpSet> getPrivateIpSets()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string privateIpAddress_;
+				std::string description_;
+				std::string zoneId_;
+				std::string resourceGroupId_;
+				bool serviceManaged_;
+				std::string instanceId_;
+				std::string vSwitchId_;
+				std::string networkInterfaceName_;
+				Attachment attachment_;
+				std::string networkInterfaceId_;
+				std::string macAddress_;
+				std::vector<std::string> securityGroupIds_;
+				long serviceID_;
+				std::string type_;
+				std::vector<Ipv6Set> ipv6Sets_;
+				int queueNumber_;
+				std::string vpcId_;
+				std::string ownerId_;
+				AssociatedPublicIp associatedPublicIp_;
+				std::string creationTime_;
+				std::vector<Tag> tags_;
+				std::vector<PrivateIpSet> privateIpSets_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBENETWORKINTERFACEATTRIBUTERESULT_H_

ecs/include/alibabacloud/ecs/model/DescribeNetworkInterfacesResult.h

@@ -39,6 +39,12 @@ namespace AlibabaCloud
 						std::string publicIpAddress;
 						std::string allocationId;
 					};
+					struct Attachment
+					{
+						std::string instanceId;
+						int deviceIndex;
+						std::string trunkNetworkInterfaceId;
+					};
 					struct PrivateIpSet
 					{
 						struct AssociatedPublicIp1
@@ -68,6 +74,7 @@ namespace AlibabaCloud
 					std::string instanceId;
 					std::string vSwitchId;
 					std::string networkInterfaceName;
+					Attachment attachment;
 					std::string networkInterfaceId;
 					std::string macAddress;
 					std::vector<std::string> securityGroupIds;

ecs/include/alibabacloud/ecs/model/DescribeSecurityGroupsRequest.h

@@ -73,6 +73,8 @@ namespace AlibabaCloud
 				void setOwnerId(long ownerId);
 				std::string getSecurityGroupIds()const;
 				void setSecurityGroupIds(const std::string& securityGroupIds);
+				std::string getSecurityGroupType()const;
+				void setSecurityGroupType(const std::string& securityGroupType);
 				std::string getVpcId()const;
 				void setVpcId(const std::string& vpcId);
 
@@ -93,6 +95,7 @@ namespace AlibabaCloud
 				std::string ownerAccount_;
 				long ownerId_;
 				std::string securityGroupIds_;
+				std::string securityGroupType_;
 				std::string vpcId_;
 
 			};

ecs/include/alibabacloud/ecs/model/DescribeSecurityGroupsResult.h

@@ -44,11 +44,13 @@ namespace AlibabaCloud
 					std::string securityGroupName;
 					std::string vpcId;
 					std::string resourceGroupId;
+					bool serviceManaged;
 					std::string securityGroupId;
 					std::string creationTime;
 					std::string securityGroupType;
 					std::vector<SecurityGroup::Tag> tags;
 					int availableInstanceAmount;
+					long serviceID;
 				};
 
 

ecs/include/alibabacloud/ecs/model/DescribeSnapshotsRequest.h

@@ -89,6 +89,8 @@ namespace AlibabaCloud
 				void setSnapshotType(const std::string& snapshotType);
 				std::string getKMSKeyId()const;
 				void setKMSKeyId(const std::string& kMSKeyId);
+				std::string getCategory()const;
+				void setCategory(const std::string& category);
 				std::string getStatus()const;
 				void setStatus(const std::string& status);
 
@@ -117,6 +119,7 @@ namespace AlibabaCloud
 				bool encrypted_;
 				std::string snapshotType_;
 				std::string kMSKeyId_;
+				std::string category_;
 				std::string status_;
 
 			};

ecs/include/alibabacloud/ecs/model/DetachNetworkInterfaceRequest.h

@@ -39,6 +39,8 @@ namespace AlibabaCloud
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getTrunkNetworkInstanceId()const;
+				void setTrunkNetworkInstanceId(const std::string& trunkNetworkInstanceId);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
@@ -53,6 +55,7 @@ namespace AlibabaCloud
             private:
 				long resourceOwnerId_;
 				std::string regionId_;
+				std::string trunkNetworkInstanceId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;

ecs/include/alibabacloud/ecs/model/ModifyAutoSnapshotPolicyExRequest.h

@@ -39,12 +39,16 @@ namespace AlibabaCloud
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getAutoSnapshotPolicyId()const;
 				void setAutoSnapshotPolicyId(const std::string& autoSnapshotPolicyId);
+				int getCopiedSnapshotsRetentionDays()const;
+				void setCopiedSnapshotsRetentionDays(int copiedSnapshotsRetentionDays);
 				std::string getTimePoints()const;
 				void setTimePoints(const std::string& timePoints);
 				std::string getRepeatWeekdays()const;
 				void setRepeatWeekdays(const std::string& repeatWeekdays);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				bool getEnableCrossRegionCopy()const;
+				void setEnableCrossRegionCopy(bool enableCrossRegionCopy);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				long getOwnerId()const;
@@ -53,17 +57,22 @@ namespace AlibabaCloud
 				void setAutoSnapshotPolicyName(const std::string& autoSnapshotPolicyName);
 				int getRetentionDays()const;
 				void setRetentionDays(int retentionDays);
+				std::string getTargetCopyRegions()const;
+				void setTargetCopyRegions(const std::string& targetCopyRegions);
 
             private:
 				long resourceOwnerId_;
 				std::string autoSnapshotPolicyId_;
+				int copiedSnapshotsRetentionDays_;
 				std::string timePoints_;
 				std::string repeatWeekdays_;
 				std::string regionId_;
+				bool enableCrossRegionCopy_;
 				std::string resourceOwnerAccount_;
 				long ownerId_;
 				std::string autoSnapshotPolicyName_;
 				int retentionDays_;
+				std::string targetCopyRegions_;
 
 			};
 		}

ecs/include/alibabacloud/ecs/model/ModifyDiskSpecRequest.h

@@ -37,8 +37,12 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::string getDiskCategory()const;
+				void setDiskCategory(const std::string& diskCategory);
 				std::string getDiskId()const;
 				void setDiskId(const std::string& diskId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getPerformanceLevel()const;
@@ -50,7 +54,9 @@ namespace AlibabaCloud
 
             private:
 				long resourceOwnerId_;
+				std::string diskCategory_;
 				std::string diskId_;
+				bool dryRun_;
 				std::string resourceOwnerAccount_;
 				std::string performanceLevel_;
 				std::string ownerAccount_;

ecs/include/alibabacloud/ecs/model/ModifyDiskSpecResult.h

@@ -37,10 +37,12 @@ namespace AlibabaCloud
 				ModifyDiskSpecResult();
 				explicit ModifyDiskSpecResult(const std::string &payload);
 				~ModifyDiskSpecResult();
+				std::string getTaskId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string taskId_;
 
 			};
 		}

ecs/include/alibabacloud/ecs/model/ModifyImageAttributeRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setImageId(const std::string& imageId);
 				std::string getDescription()const;
 				void setDescription(const std::string& description);
+				std::string getBootMode()const;
+				void setBootMode(const std::string& bootMode);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				std::string getImageName()const;
@@ -60,6 +62,7 @@ namespace AlibabaCloud
 				long resourceOwnerId_;
 				std::string imageId_;
 				std::string description_;
+				std::string bootMode_;
 				std::string regionId_;
 				std::string imageName_;
 				std::string resourceOwnerAccount_;

ecs/include/alibabacloud/ecs/model/ModifyInstanceVpcAttributeRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::vector<std::string> getSecurityGroupId()const;
+				void setSecurityGroupId(const std::vector<std::string>& securityGroupId);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
@@ -49,15 +51,19 @@ namespace AlibabaCloud
 				void setPrivateIpAddress(const std::string& privateIpAddress);
 				std::string getInstanceId()const;
 				void setInstanceId(const std::string& instanceId);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
 
             private:
 				long resourceOwnerId_;
+				std::vector<std::string> securityGroupId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
 				std::string vSwitchId_;
 				std::string privateIpAddress_;
 				std::string instanceId_;
+				std::string vpcId_;
 
 			};
 		}

ecs/src/EcsClient.cc

@@ -4947,6 +4947,42 @@ EcsClient::DescribeNatGatewaysOutcomeCallable EcsClient::describeNatGatewaysCall
 	return task->get_future();
 }
 
+EcsClient::DescribeNetworkInterfaceAttributeOutcome EcsClient::describeNetworkInterfaceAttribute(const DescribeNetworkInterfaceAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeNetworkInterfaceAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeNetworkInterfaceAttributeOutcome(DescribeNetworkInterfaceAttributeResult(outcome.result()));
+	else
+		return DescribeNetworkInterfaceAttributeOutcome(outcome.error());
+}
+
+void EcsClient::describeNetworkInterfaceAttributeAsync(const DescribeNetworkInterfaceAttributeRequest& request, const DescribeNetworkInterfaceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeNetworkInterfaceAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DescribeNetworkInterfaceAttributeOutcomeCallable EcsClient::describeNetworkInterfaceAttributeCallable(const DescribeNetworkInterfaceAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeNetworkInterfaceAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeNetworkInterfaceAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::DescribeNetworkInterfacePermissionsOutcome EcsClient::describeNetworkInterfacePermissions(const DescribeNetworkInterfacePermissionsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ecs/src/model/AttachNetworkInterfaceRequest.cc

@@ -49,6 +49,17 @@ void AttachNetworkInterfaceRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string AttachNetworkInterfaceRequest::getTrunkNetworkInstanceId()const
+{
+	return trunkNetworkInstanceId_;
+}
+
+void AttachNetworkInterfaceRequest::setTrunkNetworkInstanceId(const std::string& trunkNetworkInstanceId)
+{
+	trunkNetworkInstanceId_ = trunkNetworkInstanceId;
+	setParameter("TrunkNetworkInstanceId", trunkNetworkInstanceId);
+}
+
 std::string AttachNetworkInterfaceRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

ecs/src/model/CreateAutoSnapshotPolicyRequest.cc

@@ -38,6 +38,17 @@ void CreateAutoSnapshotPolicyRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+int CreateAutoSnapshotPolicyRequest::getCopiedSnapshotsRetentionDays()const
+{
+	return copiedSnapshotsRetentionDays_;
+}
+
+void CreateAutoSnapshotPolicyRequest::setCopiedSnapshotsRetentionDays(int copiedSnapshotsRetentionDays)
+{
+	copiedSnapshotsRetentionDays_ = copiedSnapshotsRetentionDays;
+	setParameter("CopiedSnapshotsRetentionDays", std::to_string(copiedSnapshotsRetentionDays));
+}
+
 std::string CreateAutoSnapshotPolicyRequest::getTimePoints()const
 {
 	return timePoints_;
@@ -87,6 +98,17 @@ void CreateAutoSnapshotPolicyRequest::setTag(const std::vector<Tag>& tag)
 	}
 }
 
+bool CreateAutoSnapshotPolicyRequest::getEnableCrossRegionCopy()const
+{
+	return enableCrossRegionCopy_;
+}
+
+void CreateAutoSnapshotPolicyRequest::setEnableCrossRegionCopy(bool enableCrossRegionCopy)
+{
+	enableCrossRegionCopy_ = enableCrossRegionCopy;
+	setParameter("EnableCrossRegionCopy", enableCrossRegionCopy ? "true" : "false");
+}
+
 std::string CreateAutoSnapshotPolicyRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -131,3 +153,14 @@ void CreateAutoSnapshotPolicyRequest::setRetentionDays(int retentionDays)
 	setParameter("RetentionDays", std::to_string(retentionDays));
 }
 
+std::string CreateAutoSnapshotPolicyRequest::getTargetCopyRegions()const
+{
+	return targetCopyRegions_;
+}
+
+void CreateAutoSnapshotPolicyRequest::setTargetCopyRegions(const std::string& targetCopyRegions)
+{
+	targetCopyRegions_ = targetCopyRegions;
+	setParameter("TargetCopyRegions", targetCopyRegions);
+}
+

ecs/src/model/CreateNetworkInterfaceRequest.cc

@@ -115,6 +115,17 @@ void CreateNetworkInterfaceRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string CreateNetworkInterfaceRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void CreateNetworkInterfaceRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setParameter("InstanceType", instanceType);
+}
+
 std::vector<CreateNetworkInterfaceRequest::Tag> CreateNetworkInterfaceRequest::getTag()const
 {
 	return tag_;

ecs/src/model/DescribeAutoSnapshotPolicyExResult.cc

@@ -63,6 +63,12 @@ void DescribeAutoSnapshotPolicyExResult::parse(const std::string &payload)
 			autoSnapshotPoliciesObject.creationTime = valueAutoSnapshotPoliciesAutoSnapshotPolicy["CreationTime"].asString();
 		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["Status"].isNull())
 			autoSnapshotPoliciesObject.status = valueAutoSnapshotPoliciesAutoSnapshotPolicy["Status"].asString();
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["EnableCrossRegionCopy"].isNull())
+			autoSnapshotPoliciesObject.enableCrossRegionCopy = valueAutoSnapshotPoliciesAutoSnapshotPolicy["EnableCrossRegionCopy"].asString() == "true";
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["TargetCopyRegions"].isNull())
+			autoSnapshotPoliciesObject.targetCopyRegions = valueAutoSnapshotPoliciesAutoSnapshotPolicy["TargetCopyRegions"].asString();
+		if(!valueAutoSnapshotPoliciesAutoSnapshotPolicy["CopiedSnapshotsRetentionDays"].isNull())
+			autoSnapshotPoliciesObject.copiedSnapshotsRetentionDays = std::stoi(valueAutoSnapshotPoliciesAutoSnapshotPolicy["CopiedSnapshotsRetentionDays"].asString());
 		auto allTagsNode = allAutoSnapshotPoliciesNode["Tags"]["Tag"];
 		for (auto allAutoSnapshotPoliciesNodeTagsTag : allTagsNode)
 		{