DOMAIN SDK Auto Released By lukang.zlh,Version：1.31.0

Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,8 @@
+2018-11-13 Version: 1.31.0
+1, Add FuzzyMatchDomainSensitiveWord interface，Support fuzzy matching sensitive words.
+2, Add BatchFuzzyMatchDomainSensitiveWord interface，Support batch fuzzy matching sensitive words.
+3, Add DynamicCheck properties for results of CheckDomain interface.
+
 2018-11-10 Version: 1.30.5
 1, Update SetWaitingRoomConfig.
 

VERSION

@@ -1 +1 @@
-1.30.5
+1.31.0

domain/CMakeLists.txt

@@ -97,6 +97,8 @@ set(domain_public_header_model
 	include/alibabacloud/domain/model/QueryDnsHostResult.h
 	include/alibabacloud/domain/model/QueryRegistrantProfileRealNameVerificationInfoRequest.h
 	include/alibabacloud/domain/model/QueryRegistrantProfileRealNameVerificationInfoResult.h
+	include/alibabacloud/domain/model/FuzzyMatchDomainSensitiveWordRequest.h
+	include/alibabacloud/domain/model/FuzzyMatchDomainSensitiveWordResult.h
 	include/alibabacloud/domain/model/FailDemandRequest.h
 	include/alibabacloud/domain/model/FailDemandResult.h
 	include/alibabacloud/domain/model/SaveSingleTaskForCancelingTransferInRequest.h
@@ -121,6 +123,8 @@ set(domain_public_header_model
 	include/alibabacloud/domain/model/SaveBatchTaskForCreatingOrderRenewResult.h
 	include/alibabacloud/domain/model/QueryServerLockRequest.h
 	include/alibabacloud/domain/model/QueryServerLockResult.h
+	include/alibabacloud/domain/model/BatchFuzzyMatchDomainSensitiveWordRequest.h
+	include/alibabacloud/domain/model/BatchFuzzyMatchDomainSensitiveWordResult.h
 	include/alibabacloud/domain/model/SaveSingleTaskForModifyingDnsHostRequest.h
 	include/alibabacloud/domain/model/SaveSingleTaskForModifyingDnsHostResult.h
 	include/alibabacloud/domain/model/QueryBookingDomainInfoRequest.h
@@ -314,6 +318,8 @@ set(domain_src
 	src/model/QueryDnsHostResult.cc
 	src/model/QueryRegistrantProfileRealNameVerificationInfoRequest.cc
 	src/model/QueryRegistrantProfileRealNameVerificationInfoResult.cc
+	src/model/FuzzyMatchDomainSensitiveWordRequest.cc
+	src/model/FuzzyMatchDomainSensitiveWordResult.cc
 	src/model/FailDemandRequest.cc
 	src/model/FailDemandResult.cc
 	src/model/SaveSingleTaskForCancelingTransferInRequest.cc
@@ -338,6 +344,8 @@ set(domain_src
 	src/model/SaveBatchTaskForCreatingOrderRenewResult.cc
 	src/model/QueryServerLockRequest.cc
 	src/model/QueryServerLockResult.cc
+	src/model/BatchFuzzyMatchDomainSensitiveWordRequest.cc
+	src/model/BatchFuzzyMatchDomainSensitiveWordResult.cc
 	src/model/SaveSingleTaskForModifyingDnsHostRequest.cc
 	src/model/SaveSingleTaskForModifyingDnsHostResult.cc
 	src/model/QueryBookingDomainInfoRequest.cc

domain/include/alibabacloud/domain/DomainClient.h

@@ -98,6 +98,8 @@
 #include "model/QueryDnsHostResult.h"
 #include "model/QueryRegistrantProfileRealNameVerificationInfoRequest.h"
 #include "model/QueryRegistrantProfileRealNameVerificationInfoResult.h"
+#include "model/FuzzyMatchDomainSensitiveWordRequest.h"
+#include "model/FuzzyMatchDomainSensitiveWordResult.h"
 #include "model/FailDemandRequest.h"
 #include "model/FailDemandResult.h"
 #include "model/SaveSingleTaskForCancelingTransferInRequest.h"
@@ -122,6 +124,8 @@
 #include "model/SaveBatchTaskForCreatingOrderRenewResult.h"
 #include "model/QueryServerLockRequest.h"
 #include "model/QueryServerLockResult.h"
+#include "model/BatchFuzzyMatchDomainSensitiveWordRequest.h"
+#include "model/BatchFuzzyMatchDomainSensitiveWordResult.h"
 #include "model/SaveSingleTaskForModifyingDnsHostRequest.h"
 #include "model/SaveSingleTaskForModifyingDnsHostResult.h"
 #include "model/QueryBookingDomainInfoRequest.h"
@@ -359,6 +363,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QueryRegistrantProfileRealNameVerificationInfoResult> QueryRegistrantProfileRealNameVerificationInfoOutcome;
 			typedef std::future<QueryRegistrantProfileRealNameVerificationInfoOutcome> QueryRegistrantProfileRealNameVerificationInfoOutcomeCallable;
 			typedef std::function<void(const DomainClient*, const Model::QueryRegistrantProfileRealNameVerificationInfoRequest&, const QueryRegistrantProfileRealNameVerificationInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryRegistrantProfileRealNameVerificationInfoAsyncHandler;
+			typedef Outcome<Error, Model::FuzzyMatchDomainSensitiveWordResult> FuzzyMatchDomainSensitiveWordOutcome;
+			typedef std::future<FuzzyMatchDomainSensitiveWordOutcome> FuzzyMatchDomainSensitiveWordOutcomeCallable;
+			typedef std::function<void(const DomainClient*, const Model::FuzzyMatchDomainSensitiveWordRequest&, const FuzzyMatchDomainSensitiveWordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FuzzyMatchDomainSensitiveWordAsyncHandler;
 			typedef Outcome<Error, Model::FailDemandResult> FailDemandOutcome;
 			typedef std::future<FailDemandOutcome> FailDemandOutcomeCallable;
 			typedef std::function<void(const DomainClient*, const Model::FailDemandRequest&, const FailDemandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FailDemandAsyncHandler;
@@ -395,6 +402,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QueryServerLockResult> QueryServerLockOutcome;
 			typedef std::future<QueryServerLockOutcome> QueryServerLockOutcomeCallable;
 			typedef std::function<void(const DomainClient*, const Model::QueryServerLockRequest&, const QueryServerLockOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryServerLockAsyncHandler;
+			typedef Outcome<Error, Model::BatchFuzzyMatchDomainSensitiveWordResult> BatchFuzzyMatchDomainSensitiveWordOutcome;
+			typedef std::future<BatchFuzzyMatchDomainSensitiveWordOutcome> BatchFuzzyMatchDomainSensitiveWordOutcomeCallable;
+			typedef std::function<void(const DomainClient*, const Model::BatchFuzzyMatchDomainSensitiveWordRequest&, const BatchFuzzyMatchDomainSensitiveWordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchFuzzyMatchDomainSensitiveWordAsyncHandler;
 			typedef Outcome<Error, Model::SaveSingleTaskForModifyingDnsHostResult> SaveSingleTaskForModifyingDnsHostOutcome;
 			typedef std::future<SaveSingleTaskForModifyingDnsHostOutcome> SaveSingleTaskForModifyingDnsHostOutcomeCallable;
 			typedef std::function<void(const DomainClient*, const Model::SaveSingleTaskForModifyingDnsHostRequest&, const SaveSingleTaskForModifyingDnsHostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SaveSingleTaskForModifyingDnsHostAsyncHandler;
@@ -685,6 +695,9 @@ namespace AlibabaCloud
 			QueryRegistrantProfileRealNameVerificationInfoOutcome queryRegistrantProfileRealNameVerificationInfo(const Model::QueryRegistrantProfileRealNameVerificationInfoRequest &request)const;
 			void queryRegistrantProfileRealNameVerificationInfoAsync(const Model::QueryRegistrantProfileRealNameVerificationInfoRequest& request, const QueryRegistrantProfileRealNameVerificationInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryRegistrantProfileRealNameVerificationInfoOutcomeCallable queryRegistrantProfileRealNameVerificationInfoCallable(const Model::QueryRegistrantProfileRealNameVerificationInfoRequest& request) const;
+			FuzzyMatchDomainSensitiveWordOutcome fuzzyMatchDomainSensitiveWord(const Model::FuzzyMatchDomainSensitiveWordRequest &request)const;
+			void fuzzyMatchDomainSensitiveWordAsync(const Model::FuzzyMatchDomainSensitiveWordRequest& request, const FuzzyMatchDomainSensitiveWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FuzzyMatchDomainSensitiveWordOutcomeCallable fuzzyMatchDomainSensitiveWordCallable(const Model::FuzzyMatchDomainSensitiveWordRequest& request) const;
 			FailDemandOutcome failDemand(const Model::FailDemandRequest &request)const;
 			void failDemandAsync(const Model::FailDemandRequest& request, const FailDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			FailDemandOutcomeCallable failDemandCallable(const Model::FailDemandRequest& request) const;
@@ -721,6 +734,9 @@ namespace AlibabaCloud
 			QueryServerLockOutcome queryServerLock(const Model::QueryServerLockRequest &request)const;
 			void queryServerLockAsync(const Model::QueryServerLockRequest& request, const QueryServerLockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryServerLockOutcomeCallable queryServerLockCallable(const Model::QueryServerLockRequest& request) const;
+			BatchFuzzyMatchDomainSensitiveWordOutcome batchFuzzyMatchDomainSensitiveWord(const Model::BatchFuzzyMatchDomainSensitiveWordRequest &request)const;
+			void batchFuzzyMatchDomainSensitiveWordAsync(const Model::BatchFuzzyMatchDomainSensitiveWordRequest& request, const BatchFuzzyMatchDomainSensitiveWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BatchFuzzyMatchDomainSensitiveWordOutcomeCallable batchFuzzyMatchDomainSensitiveWordCallable(const Model::BatchFuzzyMatchDomainSensitiveWordRequest& request) const;
 			SaveSingleTaskForModifyingDnsHostOutcome saveSingleTaskForModifyingDnsHost(const Model::SaveSingleTaskForModifyingDnsHostRequest &request)const;
 			void saveSingleTaskForModifyingDnsHostAsync(const Model::SaveSingleTaskForModifyingDnsHostRequest& request, const SaveSingleTaskForModifyingDnsHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SaveSingleTaskForModifyingDnsHostOutcomeCallable saveSingleTaskForModifyingDnsHostCallable(const Model::SaveSingleTaskForModifyingDnsHostRequest& request) const;

domain/include/alibabacloud/domain/model/BatchFuzzyMatchDomainSensitiveWordRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DOMAIN_MODEL_BATCHFUZZYMATCHDOMAINSENSITIVEWORDREQUEST_H_
+#define ALIBABACLOUD_DOMAIN_MODEL_BATCHFUZZYMATCHDOMAINSENSITIVEWORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/domain/DomainExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Domain
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DOMAIN_EXPORT BatchFuzzyMatchDomainSensitiveWordRequest : public RpcServiceRequest
+			{
+
+			public:
+				BatchFuzzyMatchDomainSensitiveWordRequest();
+				~BatchFuzzyMatchDomainSensitiveWordRequest();
+
+				std::string getUserClientIp()const;
+				void setUserClientIp(const std::string& userClientIp);
+				std::string getKeyword()const;
+				void setKeyword(const std::string& keyword);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string userClientIp_;
+				std::string keyword_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DOMAIN_MODEL_BATCHFUZZYMATCHDOMAINSENSITIVEWORDREQUEST_H_

domain/include/alibabacloud/domain/model/BatchFuzzyMatchDomainSensitiveWordResult.h

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

domain/include/alibabacloud/domain/model/CheckDomainResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 				std::string getDomainName()const;
 				long getPrice()const;
 				std::string getPremium()const;
+				bool getDynamicCheck()const;
 				std::string getReason()const;
 
 			protected:
@@ -50,6 +51,7 @@ namespace AlibabaCloud
 				std::string domainName_;
 				long price_;
 				std::string premium_;
+				bool dynamicCheck_;
 				std::string reason_;
 
 			};

domain/include/alibabacloud/domain/model/FuzzyMatchDomainSensitiveWordRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DOMAIN_MODEL_FUZZYMATCHDOMAINSENSITIVEWORDREQUEST_H_
+#define ALIBABACLOUD_DOMAIN_MODEL_FUZZYMATCHDOMAINSENSITIVEWORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/domain/DomainExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Domain
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DOMAIN_EXPORT FuzzyMatchDomainSensitiveWordRequest : public RpcServiceRequest
+			{
+
+			public:
+				FuzzyMatchDomainSensitiveWordRequest();
+				~FuzzyMatchDomainSensitiveWordRequest();
+
+				std::string getUserClientIp()const;
+				void setUserClientIp(const std::string& userClientIp);
+				std::string getKeyword()const;
+				void setKeyword(const std::string& keyword);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string userClientIp_;
+				std::string keyword_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DOMAIN_MODEL_FUZZYMATCHDOMAINSENSITIVEWORDREQUEST_H_

domain/include/alibabacloud/domain/model/FuzzyMatchDomainSensitiveWordResult.h

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

domain/include/alibabacloud/domain/model/QueryDomainAdminDivisionResult.h

@@ -46,23 +46,11 @@ namespace AlibabaCloud
 				QueryDomainAdminDivisionResult();
 				explicit QueryDomainAdminDivisionResult(const std::string &payload);
 				~QueryDomainAdminDivisionResult();
-				bool getPrePage()const;
-				int getCurrentPageNum()const;
-				int getPageSize()const;
-				int getTotalPageNum()const;
-				int getTotalItemNum()const;
-				bool getNextPage()const;
 				std::vector<AdminDivision> getAdminDivisions()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				bool prePage_;
-				int currentPageNum_;
-				int pageSize_;
-				int totalPageNum_;
-				int totalItemNum_;
-				bool nextPage_;
 				std::vector<AdminDivision> adminDivisions_;
 
 			};

domain/src/DomainClient.cc

@@ -1419,6 +1419,42 @@ DomainClient::QueryRegistrantProfileRealNameVerificationInfoOutcomeCallable Doma
 	return task->get_future();
 }
 
+DomainClient::FuzzyMatchDomainSensitiveWordOutcome DomainClient::fuzzyMatchDomainSensitiveWord(const FuzzyMatchDomainSensitiveWordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FuzzyMatchDomainSensitiveWordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FuzzyMatchDomainSensitiveWordOutcome(FuzzyMatchDomainSensitiveWordResult(outcome.result()));
+	else
+		return FuzzyMatchDomainSensitiveWordOutcome(outcome.error());
+}
+
+void DomainClient::fuzzyMatchDomainSensitiveWordAsync(const FuzzyMatchDomainSensitiveWordRequest& request, const FuzzyMatchDomainSensitiveWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, fuzzyMatchDomainSensitiveWord(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DomainClient::FuzzyMatchDomainSensitiveWordOutcomeCallable DomainClient::fuzzyMatchDomainSensitiveWordCallable(const FuzzyMatchDomainSensitiveWordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FuzzyMatchDomainSensitiveWordOutcome()>>(
+			[this, request]()
+			{
+			return this->fuzzyMatchDomainSensitiveWord(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DomainClient::FailDemandOutcome DomainClient::failDemand(const FailDemandRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1851,6 +1887,42 @@ DomainClient::QueryServerLockOutcomeCallable DomainClient::queryServerLockCallab
 	return task->get_future();
 }
 
+DomainClient::BatchFuzzyMatchDomainSensitiveWordOutcome DomainClient::batchFuzzyMatchDomainSensitiveWord(const BatchFuzzyMatchDomainSensitiveWordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BatchFuzzyMatchDomainSensitiveWordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BatchFuzzyMatchDomainSensitiveWordOutcome(BatchFuzzyMatchDomainSensitiveWordResult(outcome.result()));
+	else
+		return BatchFuzzyMatchDomainSensitiveWordOutcome(outcome.error());
+}
+
+void DomainClient::batchFuzzyMatchDomainSensitiveWordAsync(const BatchFuzzyMatchDomainSensitiveWordRequest& request, const BatchFuzzyMatchDomainSensitiveWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, batchFuzzyMatchDomainSensitiveWord(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DomainClient::BatchFuzzyMatchDomainSensitiveWordOutcomeCallable DomainClient::batchFuzzyMatchDomainSensitiveWordCallable(const BatchFuzzyMatchDomainSensitiveWordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BatchFuzzyMatchDomainSensitiveWordOutcome()>>(
+			[this, request]()
+			{
+			return this->batchFuzzyMatchDomainSensitiveWord(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DomainClient::SaveSingleTaskForModifyingDnsHostOutcome DomainClient::saveSingleTaskForModifyingDnsHost(const SaveSingleTaskForModifyingDnsHostRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

domain/src/model/BatchFuzzyMatchDomainSensitiveWordRequest.cc

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/domain/model/BatchFuzzyMatchDomainSensitiveWordRequest.h>
+
+using AlibabaCloud::Domain::Model::BatchFuzzyMatchDomainSensitiveWordRequest;
+
+BatchFuzzyMatchDomainSensitiveWordRequest::BatchFuzzyMatchDomainSensitiveWordRequest() :
+	RpcServiceRequest("domain", "2018-01-29", "BatchFuzzyMatchDomainSensitiveWord")
+{}
+
+BatchFuzzyMatchDomainSensitiveWordRequest::~BatchFuzzyMatchDomainSensitiveWordRequest()
+{}
+
+std::string BatchFuzzyMatchDomainSensitiveWordRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void BatchFuzzyMatchDomainSensitiveWordRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string BatchFuzzyMatchDomainSensitiveWordRequest::getKeyword()const
+{
+	return keyword_;
+}
+
+void BatchFuzzyMatchDomainSensitiveWordRequest::setKeyword(const std::string& keyword)
+{
+	keyword_ = keyword;
+	setParameter("Keyword", keyword);
+}
+
+std::string BatchFuzzyMatchDomainSensitiveWordRequest::getLang()const
+{
+	return lang_;
+}
+
+void BatchFuzzyMatchDomainSensitiveWordRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

domain/src/model/BatchFuzzyMatchDomainSensitiveWordResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/domain/model/BatchFuzzyMatchDomainSensitiveWordResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Domain;
+using namespace AlibabaCloud::Domain::Model;
+
+BatchFuzzyMatchDomainSensitiveWordResult::BatchFuzzyMatchDomainSensitiveWordResult() :
+	ServiceResult()
+{}
+
+BatchFuzzyMatchDomainSensitiveWordResult::BatchFuzzyMatchDomainSensitiveWordResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+BatchFuzzyMatchDomainSensitiveWordResult::~BatchFuzzyMatchDomainSensitiveWordResult()
+{}
+
+void BatchFuzzyMatchDomainSensitiveWordResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allSensitiveWordMatchResultList = value["SensitiveWordMatchResultList"]["SensitiveWordMatchResult"];
+	for (auto value : allSensitiveWordMatchResultList)
+	{
+		SensitiveWordMatchResult sensitiveWordMatchResultListObject;
+		if(!value["Keyword"].isNull())
+			sensitiveWordMatchResultListObject.keyword = value["Keyword"].asString();
+		if(!value["Exist"].isNull())
+			sensitiveWordMatchResultListObject.exist = value["Exist"].asString() == "true";
+		auto allMatchedSentiveWords = value["MatchedSentiveWords"]["MatchedSensitiveWord"];
+		for (auto value : allMatchedSentiveWords)
+		{
+			SensitiveWordMatchResult::MatchedSensitiveWord matchedSentiveWordsObject;
+			if(!value["Word"].isNull())
+				matchedSentiveWordsObject.word = value["Word"].asString();
+			sensitiveWordMatchResultListObject.matchedSentiveWords.push_back(matchedSentiveWordsObject);
+		}
+		sensitiveWordMatchResultList_.push_back(sensitiveWordMatchResultListObject);
+	}
+
+}
+
+std::vector<BatchFuzzyMatchDomainSensitiveWordResult::SensitiveWordMatchResult> BatchFuzzyMatchDomainSensitiveWordResult::getSensitiveWordMatchResultList()const
+{
+	return sensitiveWordMatchResultList_;
+}
+

domain/src/model/CheckDomainResult.cc

@@ -50,6 +50,8 @@ void CheckDomainResult::parse(const std::string &payload)
 		reason_ = value["Reason"].asString();
 	if(!value["Price"].isNull())
 		price_ = std::stol(value["Price"].asString());
+	if(!value["DynamicCheck"].isNull())
+		dynamicCheck_ = value["DynamicCheck"].asString() == "true";
 
 }
 
@@ -73,6 +75,11 @@ std::string CheckDomainResult::getPremium()const
 	return premium_;
 }
 
+bool CheckDomainResult::getDynamicCheck()const
+{
+	return dynamicCheck_;
+}
+
 std::string CheckDomainResult::getReason()const
 {
 	return reason_;

domain/src/model/FuzzyMatchDomainSensitiveWordRequest.cc

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/domain/model/FuzzyMatchDomainSensitiveWordRequest.h>
+
+using AlibabaCloud::Domain::Model::FuzzyMatchDomainSensitiveWordRequest;
+
+FuzzyMatchDomainSensitiveWordRequest::FuzzyMatchDomainSensitiveWordRequest() :
+	RpcServiceRequest("domain", "2018-01-29", "FuzzyMatchDomainSensitiveWord")
+{}
+
+FuzzyMatchDomainSensitiveWordRequest::~FuzzyMatchDomainSensitiveWordRequest()
+{}
+
+std::string FuzzyMatchDomainSensitiveWordRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void FuzzyMatchDomainSensitiveWordRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string FuzzyMatchDomainSensitiveWordRequest::getKeyword()const
+{
+	return keyword_;
+}
+
+void FuzzyMatchDomainSensitiveWordRequest::setKeyword(const std::string& keyword)
+{
+	keyword_ = keyword;
+	setParameter("Keyword", keyword);
+}
+
+std::string FuzzyMatchDomainSensitiveWordRequest::getLang()const
+{
+	return lang_;
+}
+
+void FuzzyMatchDomainSensitiveWordRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

domain/src/model/FuzzyMatchDomainSensitiveWordResult.cc

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

domain/src/model/QueryDomainAdminDivisionResult.cc

@@ -56,51 +56,9 @@ void QueryDomainAdminDivisionResult::parse(const std::string &payload)
 		}
 		adminDivisions_.push_back(adminDivisionsObject);
 	}
-	if(!value["TotalItemNum"].isNull())
-		totalItemNum_ = std::stoi(value["TotalItemNum"].asString());
-	if(!value["CurrentPageNum"].isNull())
-		currentPageNum_ = std::stoi(value["CurrentPageNum"].asString());
-	if(!value["TotalPageNum"].isNull())
-		totalPageNum_ = std::stoi(value["TotalPageNum"].asString());
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
-	if(!value["PrePage"].isNull())
-		prePage_ = value["PrePage"].asString() == "true";
-	if(!value["NextPage"].isNull())
-		nextPage_ = value["NextPage"].asString() == "true";
 
 }
 
-bool QueryDomainAdminDivisionResult::getPrePage()const
-{
-	return prePage_;
-}
-
-int QueryDomainAdminDivisionResult::getCurrentPageNum()const
-{
-	return currentPageNum_;
-}
-
-int QueryDomainAdminDivisionResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int QueryDomainAdminDivisionResult::getTotalPageNum()const
-{
-	return totalPageNum_;
-}
-
-int QueryDomainAdminDivisionResult::getTotalItemNum()const
-{
-	return totalItemNum_;
-}
-
-bool QueryDomainAdminDivisionResult::getNextPage()const
-{
-	return nextPage_;
-}
-
 std::vector<QueryDomainAdminDivisionResult::AdminDivision> QueryDomainAdminDivisionResult::getAdminDivisions()const
 {
 	return adminDivisions_;