Supported sdk for sddp.

CHANGELOG

@@ -1,3 +1,9 @@
+2021-09-26 Version: 1.36.885
+- Supported sdk for sddp.
+
+2021-09-24 Version: 1.36.884
+- Release RetouchSkin LiquifyFace.
+
 2021-09-23 Version: 1.36.883
 - Supports the purchase of polardb storage packages.
 - Support temporary upgrades and allocations of instances.

VERSION

@@ -1 +1 @@
-1.36.883
+1.36.885

facebody/CMakeLists.txt

@@ -107,6 +107,8 @@ set(facebody_public_header_model
 	include/alibabacloud/facebody/model/GetRealPersonVerificationResultResult.h
 	include/alibabacloud/facebody/model/HandPostureRequest.h
 	include/alibabacloud/facebody/model/HandPostureResult.h
+	include/alibabacloud/facebody/model/LiquifyFaceRequest.h
+	include/alibabacloud/facebody/model/LiquifyFaceResult.h
 	include/alibabacloud/facebody/model/ListBodyDbsRequest.h
 	include/alibabacloud/facebody/model/ListBodyDbsResult.h
 	include/alibabacloud/facebody/model/ListBodyPersonRequest.h
@@ -135,6 +137,8 @@ set(facebody_public_header_model
 	include/alibabacloud/facebody/model/RecognizePublicFaceResult.h
 	include/alibabacloud/facebody/model/RetouchBodyRequest.h
 	include/alibabacloud/facebody/model/RetouchBodyResult.h
+	include/alibabacloud/facebody/model/RetouchSkinRequest.h
+	include/alibabacloud/facebody/model/RetouchSkinResult.h
 	include/alibabacloud/facebody/model/SearchBodyTraceRequest.h
 	include/alibabacloud/facebody/model/SearchBodyTraceResult.h
 	include/alibabacloud/facebody/model/SearchFaceRequest.h
@@ -234,6 +238,8 @@ set(facebody_src
 	src/model/GetRealPersonVerificationResultResult.cc
 	src/model/HandPostureRequest.cc
 	src/model/HandPostureResult.cc
+	src/model/LiquifyFaceRequest.cc
+	src/model/LiquifyFaceResult.cc
 	src/model/ListBodyDbsRequest.cc
 	src/model/ListBodyDbsResult.cc
 	src/model/ListBodyPersonRequest.cc
@@ -262,6 +268,8 @@ set(facebody_src
 	src/model/RecognizePublicFaceResult.cc
 	src/model/RetouchBodyRequest.cc
 	src/model/RetouchBodyResult.cc
+	src/model/RetouchSkinRequest.cc
+	src/model/RetouchSkinResult.cc
 	src/model/SearchBodyTraceRequest.cc
 	src/model/SearchBodyTraceResult.cc
 	src/model/SearchFaceRequest.cc

facebody/include/alibabacloud/facebody/FacebodyClient.h

@@ -108,6 +108,8 @@
 #include "model/GetRealPersonVerificationResultResult.h"
 #include "model/HandPostureRequest.h"
 #include "model/HandPostureResult.h"
+#include "model/LiquifyFaceRequest.h"
+#include "model/LiquifyFaceResult.h"
 #include "model/ListBodyDbsRequest.h"
 #include "model/ListBodyDbsResult.h"
 #include "model/ListBodyPersonRequest.h"
@@ -136,6 +138,8 @@
 #include "model/RecognizePublicFaceResult.h"
 #include "model/RetouchBodyRequest.h"
 #include "model/RetouchBodyResult.h"
+#include "model/RetouchSkinRequest.h"
+#include "model/RetouchSkinResult.h"
 #include "model/SearchBodyTraceRequest.h"
 #include "model/SearchBodyTraceResult.h"
 #include "model/SearchFaceRequest.h"
@@ -284,6 +288,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::HandPostureResult> HandPostureOutcome;
 			typedef std::future<HandPostureOutcome> HandPostureOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::HandPostureRequest&, const HandPostureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HandPostureAsyncHandler;
+			typedef Outcome<Error, Model::LiquifyFaceResult> LiquifyFaceOutcome;
+			typedef std::future<LiquifyFaceOutcome> LiquifyFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::LiquifyFaceRequest&, const LiquifyFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LiquifyFaceAsyncHandler;
 			typedef Outcome<Error, Model::ListBodyDbsResult> ListBodyDbsOutcome;
 			typedef std::future<ListBodyDbsOutcome> ListBodyDbsOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::ListBodyDbsRequest&, const ListBodyDbsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListBodyDbsAsyncHandler;
@@ -326,6 +333,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RetouchBodyResult> RetouchBodyOutcome;
 			typedef std::future<RetouchBodyOutcome> RetouchBodyOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::RetouchBodyRequest&, const RetouchBodyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetouchBodyAsyncHandler;
+			typedef Outcome<Error, Model::RetouchSkinResult> RetouchSkinOutcome;
+			typedef std::future<RetouchSkinOutcome> RetouchSkinOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::RetouchSkinRequest&, const RetouchSkinOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetouchSkinAsyncHandler;
 			typedef Outcome<Error, Model::SearchBodyTraceResult> SearchBodyTraceOutcome;
 			typedef std::future<SearchBodyTraceOutcome> SearchBodyTraceOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::SearchBodyTraceRequest&, const SearchBodyTraceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchBodyTraceAsyncHandler;
@@ -475,6 +485,9 @@ namespace AlibabaCloud
 			HandPostureOutcome handPosture(const Model::HandPostureRequest &request)const;
 			void handPostureAsync(const Model::HandPostureRequest& request, const HandPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			HandPostureOutcomeCallable handPostureCallable(const Model::HandPostureRequest& request) const;
+			LiquifyFaceOutcome liquifyFace(const Model::LiquifyFaceRequest &request)const;
+			void liquifyFaceAsync(const Model::LiquifyFaceRequest& request, const LiquifyFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			LiquifyFaceOutcomeCallable liquifyFaceCallable(const Model::LiquifyFaceRequest& request) const;
 			ListBodyDbsOutcome listBodyDbs(const Model::ListBodyDbsRequest &request)const;
 			void listBodyDbsAsync(const Model::ListBodyDbsRequest& request, const ListBodyDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListBodyDbsOutcomeCallable listBodyDbsCallable(const Model::ListBodyDbsRequest& request) const;
@@ -517,6 +530,9 @@ namespace AlibabaCloud
 			RetouchBodyOutcome retouchBody(const Model::RetouchBodyRequest &request)const;
 			void retouchBodyAsync(const Model::RetouchBodyRequest& request, const RetouchBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RetouchBodyOutcomeCallable retouchBodyCallable(const Model::RetouchBodyRequest& request) const;
+			RetouchSkinOutcome retouchSkin(const Model::RetouchSkinRequest &request)const;
+			void retouchSkinAsync(const Model::RetouchSkinRequest& request, const RetouchSkinAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RetouchSkinOutcomeCallable retouchSkinCallable(const Model::RetouchSkinRequest& request) const;
 			SearchBodyTraceOutcome searchBodyTrace(const Model::SearchBodyTraceRequest &request)const;
 			void searchBodyTraceAsync(const Model::SearchBodyTraceRequest& request, const SearchBodyTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SearchBodyTraceOutcomeCallable searchBodyTraceCallable(const Model::SearchBodyTraceRequest& request) const;

facebody/include/alibabacloud/facebody/model/LiquifyFaceRequest.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_FACEBODY_MODEL_LIQUIFYFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_LIQUIFYFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT LiquifyFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				LiquifyFaceRequest();
+				~LiquifyFaceRequest();
+
+				float getSlimDegree()const;
+				void setSlimDegree(float slimDegree);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				float slimDegree_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_LIQUIFYFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/LiquifyFaceResult.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_FACEBODY_MODEL_LIQUIFYFACERESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_LIQUIFYFACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT LiquifyFaceResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string imageURL;
+				};
+
+
+				LiquifyFaceResult();
+				explicit LiquifyFaceResult(const std::string &payload);
+				~LiquifyFaceResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_LIQUIFYFACERESULT_H_

facebody/include/alibabacloud/facebody/model/RetouchSkinRequest.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_FACEBODY_MODEL_RETOUCHSKINREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_RETOUCHSKINREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT RetouchSkinRequest : public RpcServiceRequest
+			{
+
+			public:
+				RetouchSkinRequest();
+				~RetouchSkinRequest();
+
+				float getRetouchDegree()const;
+				void setRetouchDegree(float retouchDegree);
+				float getWhiteningDegree()const;
+				void setWhiteningDegree(float whiteningDegree);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				float retouchDegree_;
+				float whiteningDegree_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_RETOUCHSKINREQUEST_H_

facebody/include/alibabacloud/facebody/model/RetouchSkinResult.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_FACEBODY_MODEL_RETOUCHSKINRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_RETOUCHSKINRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT RetouchSkinResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string imageURL;
+				};
+
+
+				RetouchSkinResult();
+				explicit RetouchSkinResult(const std::string &payload);
+				~RetouchSkinResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_RETOUCHSKINRESULT_H_

facebody/src/FacebodyClient.cc

@@ -1599,6 +1599,42 @@ FacebodyClient::HandPostureOutcomeCallable FacebodyClient::handPostureCallable(c
 	return task->get_future();
 }
 
+FacebodyClient::LiquifyFaceOutcome FacebodyClient::liquifyFace(const LiquifyFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return LiquifyFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return LiquifyFaceOutcome(LiquifyFaceResult(outcome.result()));
+	else
+		return LiquifyFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::liquifyFaceAsync(const LiquifyFaceRequest& request, const LiquifyFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, liquifyFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::LiquifyFaceOutcomeCallable FacebodyClient::liquifyFaceCallable(const LiquifyFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<LiquifyFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->liquifyFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FacebodyClient::ListBodyDbsOutcome FacebodyClient::listBodyDbs(const ListBodyDbsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2103,6 +2139,42 @@ FacebodyClient::RetouchBodyOutcomeCallable FacebodyClient::retouchBodyCallable(c
 	return task->get_future();
 }
 
+FacebodyClient::RetouchSkinOutcome FacebodyClient::retouchSkin(const RetouchSkinRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RetouchSkinOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RetouchSkinOutcome(RetouchSkinResult(outcome.result()));
+	else
+		return RetouchSkinOutcome(outcome.error());
+}
+
+void FacebodyClient::retouchSkinAsync(const RetouchSkinRequest& request, const RetouchSkinAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, retouchSkin(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::RetouchSkinOutcomeCallable FacebodyClient::retouchSkinCallable(const RetouchSkinRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RetouchSkinOutcome()>>(
+			[this, request]()
+			{
+			return this->retouchSkin(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FacebodyClient::SearchBodyTraceOutcome FacebodyClient::searchBodyTrace(const SearchBodyTraceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

facebody/src/model/LiquifyFaceRequest.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/facebody/model/LiquifyFaceRequest.h>
+
+using AlibabaCloud::Facebody::Model::LiquifyFaceRequest;
+
+LiquifyFaceRequest::LiquifyFaceRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "LiquifyFace")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+LiquifyFaceRequest::~LiquifyFaceRequest()
+{}
+
+float LiquifyFaceRequest::getSlimDegree()const
+{
+	return slimDegree_;
+}
+
+void LiquifyFaceRequest::setSlimDegree(float slimDegree)
+{
+	slimDegree_ = slimDegree;
+	setBodyParameter("SlimDegree", std::to_string(slimDegree));
+}
+
+std::string LiquifyFaceRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void LiquifyFaceRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

facebody/src/model/LiquifyFaceResult.cc

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

facebody/src/model/RetouchSkinRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/facebody/model/RetouchSkinRequest.h>
+
+using AlibabaCloud::Facebody::Model::RetouchSkinRequest;
+
+RetouchSkinRequest::RetouchSkinRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "RetouchSkin")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RetouchSkinRequest::~RetouchSkinRequest()
+{}
+
+float RetouchSkinRequest::getRetouchDegree()const
+{
+	return retouchDegree_;
+}
+
+void RetouchSkinRequest::setRetouchDegree(float retouchDegree)
+{
+	retouchDegree_ = retouchDegree;
+	setBodyParameter("RetouchDegree", std::to_string(retouchDegree));
+}
+
+float RetouchSkinRequest::getWhiteningDegree()const
+{
+	return whiteningDegree_;
+}
+
+void RetouchSkinRequest::setWhiteningDegree(float whiteningDegree)
+{
+	whiteningDegree_ = whiteningDegree;
+	setBodyParameter("WhiteningDegree", std::to_string(whiteningDegree));
+}
+
+std::string RetouchSkinRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void RetouchSkinRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

facebody/src/model/RetouchSkinResult.cc

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

sddp/CMakeLists.txt

@@ -21,14 +21,16 @@ set(sddp_public_header
 	include/alibabacloud/sddp/SddpExport.h )
 
 set(sddp_public_header_model 
+	include/alibabacloud/sddp/model/BatchDeleteDataLimitRequest.h
+	include/alibabacloud/sddp/model/BatchDeleteDataLimitResult.h
 	include/alibabacloud/sddp/model/CreateConfigRequest.h
 	include/alibabacloud/sddp/model/CreateConfigResult.h
 	include/alibabacloud/sddp/model/CreateDataLimitRequest.h
 	include/alibabacloud/sddp/model/CreateDataLimitResult.h
 	include/alibabacloud/sddp/model/CreateRuleRequest.h
 	include/alibabacloud/sddp/model/CreateRuleResult.h
-	include/alibabacloud/sddp/model/CreateUserAuthRequest.h
-	include/alibabacloud/sddp/model/CreateUserAuthResult.h
+	include/alibabacloud/sddp/model/CreateScanTaskRequest.h
+	include/alibabacloud/sddp/model/CreateScanTaskResult.h
 	include/alibabacloud/sddp/model/DeleteDataLimitRequest.h
 	include/alibabacloud/sddp/model/DeleteDataLimitResult.h
 	include/alibabacloud/sddp/model/DeleteRuleRequest.h
@@ -37,64 +39,62 @@ set(sddp_public_header_model
 	include/alibabacloud/sddp/model/DescribeAccountDetailResult.h
 	include/alibabacloud/sddp/model/DescribeAccountsRequest.h
 	include/alibabacloud/sddp/model/DescribeAccountsResult.h
-	include/alibabacloud/sddp/model/DescribeAuditLogsRequest.h
-	include/alibabacloud/sddp/model/DescribeAuditLogsResult.h
-	include/alibabacloud/sddp/model/DescribeAuthAccountsRequest.h
-	include/alibabacloud/sddp/model/DescribeAuthAccountsResult.h
-	include/alibabacloud/sddp/model/DescribeCloudDatabasesRequest.h
-	include/alibabacloud/sddp/model/DescribeCloudDatabasesResult.h
-	include/alibabacloud/sddp/model/DescribeCloudInstancesRequest.h
-	include/alibabacloud/sddp/model/DescribeCloudInstancesResult.h
 	include/alibabacloud/sddp/model/DescribeColumnsRequest.h
 	include/alibabacloud/sddp/model/DescribeColumnsResult.h
 	include/alibabacloud/sddp/model/DescribeConfigsRequest.h
 	include/alibabacloud/sddp/model/DescribeConfigsResult.h
 	include/alibabacloud/sddp/model/DescribeDataAssetsRequest.h
 	include/alibabacloud/sddp/model/DescribeDataAssetsResult.h
-	include/alibabacloud/sddp/model/DescribeDataHubConnectorsRequest.h
-	include/alibabacloud/sddp/model/DescribeDataHubConnectorsResult.h
-	include/alibabacloud/sddp/model/DescribeDataHubProjectsRequest.h
-	include/alibabacloud/sddp/model/DescribeDataHubProjectsResult.h
-	include/alibabacloud/sddp/model/DescribeDataHubSubscriptionsRequest.h
-	include/alibabacloud/sddp/model/DescribeDataHubSubscriptionsResult.h
-	include/alibabacloud/sddp/model/DescribeDataHubTopicsRequest.h
-	include/alibabacloud/sddp/model/DescribeDataHubTopicsResult.h
 	include/alibabacloud/sddp/model/DescribeDataLimitDetailRequest.h
 	include/alibabacloud/sddp/model/DescribeDataLimitDetailResult.h
+	include/alibabacloud/sddp/model/DescribeDataLimitSetRequest.h
+	include/alibabacloud/sddp/model/DescribeDataLimitSetResult.h
 	include/alibabacloud/sddp/model/DescribeDataLimitsRequest.h
 	include/alibabacloud/sddp/model/DescribeDataLimitsResult.h
+	include/alibabacloud/sddp/model/DescribeDataLimitsInstanceDimRequest.h
+	include/alibabacloud/sddp/model/DescribeDataLimitsInstanceDimResult.h
 	include/alibabacloud/sddp/model/DescribeDataMaskingRunHistoryRequest.h
 	include/alibabacloud/sddp/model/DescribeDataMaskingRunHistoryResult.h
 	include/alibabacloud/sddp/model/DescribeDataMaskingTasksRequest.h
 	include/alibabacloud/sddp/model/DescribeDataMaskingTasksResult.h
-	include/alibabacloud/sddp/model/DescribeDepartsRequest.h
-	include/alibabacloud/sddp/model/DescribeDepartsResult.h
+	include/alibabacloud/sddp/model/DescribeDataTotalCountRequest.h
+	include/alibabacloud/sddp/model/DescribeDataTotalCountResult.h
 	include/alibabacloud/sddp/model/DescribeEventDetailRequest.h
 	include/alibabacloud/sddp/model/DescribeEventDetailResult.h
+	include/alibabacloud/sddp/model/DescribeEventTopRequest.h
+	include/alibabacloud/sddp/model/DescribeEventTopResult.h
 	include/alibabacloud/sddp/model/DescribeEventTypesRequest.h
 	include/alibabacloud/sddp/model/DescribeEventTypesResult.h
+	include/alibabacloud/sddp/model/DescribeEventTypesDetailRequest.h
+	include/alibabacloud/sddp/model/DescribeEventTypesDetailResult.h
 	include/alibabacloud/sddp/model/DescribeEventsRequest.h
 	include/alibabacloud/sddp/model/DescribeEventsResult.h
+	include/alibabacloud/sddp/model/DescribeInstancePortraitRequest.h
+	include/alibabacloud/sddp/model/DescribeInstancePortraitResult.h
+	include/alibabacloud/sddp/model/DescribeInstanceSourcesRequest.h
+	include/alibabacloud/sddp/model/DescribeInstanceSourcesResult.h
 	include/alibabacloud/sddp/model/DescribeInstancesRequest.h
 	include/alibabacloud/sddp/model/DescribeInstancesResult.h
-	include/alibabacloud/sddp/model/DescribeOriginalLogsRequest.h
-	include/alibabacloud/sddp/model/DescribeOriginalLogsResult.h
 	include/alibabacloud/sddp/model/DescribeOssObjectDetailRequest.h
 	include/alibabacloud/sddp/model/DescribeOssObjectDetailResult.h
 	include/alibabacloud/sddp/model/DescribeOssObjectsRequest.h
 	include/alibabacloud/sddp/model/DescribeOssObjectsResult.h
 	include/alibabacloud/sddp/model/DescribePackagesRequest.h
 	include/alibabacloud/sddp/model/DescribePackagesResult.h
-	include/alibabacloud/sddp/model/DescribePrivilegesRequest.h
-	include/alibabacloud/sddp/model/DescribePrivilegesResult.h
+	include/alibabacloud/sddp/model/DescribeRiskLevelsRequest.h
+	include/alibabacloud/sddp/model/DescribeRiskLevelsResult.h
+	include/alibabacloud/sddp/model/DescribeRuleCategoryRequest.h
+	include/alibabacloud/sddp/model/DescribeRuleCategoryResult.h
 	include/alibabacloud/sddp/model/DescribeRulesRequest.h
 	include/alibabacloud/sddp/model/DescribeRulesResult.h
 	include/alibabacloud/sddp/model/DescribeTablesRequest.h
 	include/alibabacloud/sddp/model/DescribeTablesResult.h
-	include/alibabacloud/sddp/model/DescribeUseFlowRequest.h
-	include/alibabacloud/sddp/model/DescribeUseFlowResult.h
+	include/alibabacloud/sddp/model/DescribeUserCountRequest.h
+	include/alibabacloud/sddp/model/DescribeUserCountResult.h
 	include/alibabacloud/sddp/model/DescribeUserStatusRequest.h
 	include/alibabacloud/sddp/model/DescribeUserStatusResult.h
+	include/alibabacloud/sddp/model/DisableUserConfigRequest.h
+	include/alibabacloud/sddp/model/DisableUserConfigResult.h
 	include/alibabacloud/sddp/model/ExecDatamaskRequest.h
 	include/alibabacloud/sddp/model/ExecDatamaskResult.h
 	include/alibabacloud/sddp/model/ManualTriggerMaskingProcessRequest.h
@@ -111,21 +111,21 @@ set(sddp_public_header_model
 	include/alibabacloud/sddp/model/ModifyRuleResult.h
 	include/alibabacloud/sddp/model/ModifyRuleStatusRequest.h
 	include/alibabacloud/sddp/model/ModifyRuleStatusResult.h
-	include/alibabacloud/sddp/model/ModifySaleFlowCountTypeRequest.h
-	include/alibabacloud/sddp/model/ModifySaleFlowCountTypeResult.h
-	include/alibabacloud/sddp/model/ValidateConnectorRequest.h
-	include/alibabacloud/sddp/model/ValidateConnectorResult.h )
+	include/alibabacloud/sddp/model/StopMaskingProcessRequest.h
+	include/alibabacloud/sddp/model/StopMaskingProcessResult.h )
 
 set(sddp_src 
 	src/SddpClient.cc
+	src/model/BatchDeleteDataLimitRequest.cc
+	src/model/BatchDeleteDataLimitResult.cc
 	src/model/CreateConfigRequest.cc
 	src/model/CreateConfigResult.cc
 	src/model/CreateDataLimitRequest.cc
 	src/model/CreateDataLimitResult.cc
 	src/model/CreateRuleRequest.cc
 	src/model/CreateRuleResult.cc
-	src/model/CreateUserAuthRequest.cc
-	src/model/CreateUserAuthResult.cc
+	src/model/CreateScanTaskRequest.cc
+	src/model/CreateScanTaskResult.cc
 	src/model/DeleteDataLimitRequest.cc
 	src/model/DeleteDataLimitResult.cc
 	src/model/DeleteRuleRequest.cc
@@ -134,64 +134,62 @@ set(sddp_src
 	src/model/DescribeAccountDetailResult.cc
 	src/model/DescribeAccountsRequest.cc
 	src/model/DescribeAccountsResult.cc
-	src/model/DescribeAuditLogsRequest.cc
-	src/model/DescribeAuditLogsResult.cc
-	src/model/DescribeAuthAccountsRequest.cc
-	src/model/DescribeAuthAccountsResult.cc
-	src/model/DescribeCloudDatabasesRequest.cc
-	src/model/DescribeCloudDatabasesResult.cc
-	src/model/DescribeCloudInstancesRequest.cc
-	src/model/DescribeCloudInstancesResult.cc
 	src/model/DescribeColumnsRequest.cc
 	src/model/DescribeColumnsResult.cc
 	src/model/DescribeConfigsRequest.cc
 	src/model/DescribeConfigsResult.cc
 	src/model/DescribeDataAssetsRequest.cc
 	src/model/DescribeDataAssetsResult.cc
-	src/model/DescribeDataHubConnectorsRequest.cc
-	src/model/DescribeDataHubConnectorsResult.cc
-	src/model/DescribeDataHubProjectsRequest.cc
-	src/model/DescribeDataHubProjectsResult.cc
-	src/model/DescribeDataHubSubscriptionsRequest.cc
-	src/model/DescribeDataHubSubscriptionsResult.cc
-	src/model/DescribeDataHubTopicsRequest.cc
-	src/model/DescribeDataHubTopicsResult.cc
 	src/model/DescribeDataLimitDetailRequest.cc
 	src/model/DescribeDataLimitDetailResult.cc
+	src/model/DescribeDataLimitSetRequest.cc
+	src/model/DescribeDataLimitSetResult.cc
 	src/model/DescribeDataLimitsRequest.cc
 	src/model/DescribeDataLimitsResult.cc
+	src/model/DescribeDataLimitsInstanceDimRequest.cc
+	src/model/DescribeDataLimitsInstanceDimResult.cc
 	src/model/DescribeDataMaskingRunHistoryRequest.cc
 	src/model/DescribeDataMaskingRunHistoryResult.cc
 	src/model/DescribeDataMaskingTasksRequest.cc
 	src/model/DescribeDataMaskingTasksResult.cc
-	src/model/DescribeDepartsRequest.cc
-	src/model/DescribeDepartsResult.cc
+	src/model/DescribeDataTotalCountRequest.cc
+	src/model/DescribeDataTotalCountResult.cc
 	src/model/DescribeEventDetailRequest.cc
 	src/model/DescribeEventDetailResult.cc
+	src/model/DescribeEventTopRequest.cc
+	src/model/DescribeEventTopResult.cc
 	src/model/DescribeEventTypesRequest.cc
 	src/model/DescribeEventTypesResult.cc
+	src/model/DescribeEventTypesDetailRequest.cc
+	src/model/DescribeEventTypesDetailResult.cc
 	src/model/DescribeEventsRequest.cc
 	src/model/DescribeEventsResult.cc
+	src/model/DescribeInstancePortraitRequest.cc
+	src/model/DescribeInstancePortraitResult.cc
+	src/model/DescribeInstanceSourcesRequest.cc
+	src/model/DescribeInstanceSourcesResult.cc
 	src/model/DescribeInstancesRequest.cc
 	src/model/DescribeInstancesResult.cc
-	src/model/DescribeOriginalLogsRequest.cc
-	src/model/DescribeOriginalLogsResult.cc
 	src/model/DescribeOssObjectDetailRequest.cc
 	src/model/DescribeOssObjectDetailResult.cc
 	src/model/DescribeOssObjectsRequest.cc
 	src/model/DescribeOssObjectsResult.cc
 	src/model/DescribePackagesRequest.cc
 	src/model/DescribePackagesResult.cc
-	src/model/DescribePrivilegesRequest.cc
-	src/model/DescribePrivilegesResult.cc
+	src/model/DescribeRiskLevelsRequest.cc
+	src/model/DescribeRiskLevelsResult.cc
+	src/model/DescribeRuleCategoryRequest.cc
+	src/model/DescribeRuleCategoryResult.cc
 	src/model/DescribeRulesRequest.cc
 	src/model/DescribeRulesResult.cc
 	src/model/DescribeTablesRequest.cc
 	src/model/DescribeTablesResult.cc
-	src/model/DescribeUseFlowRequest.cc
-	src/model/DescribeUseFlowResult.cc
+	src/model/DescribeUserCountRequest.cc
+	src/model/DescribeUserCountResult.cc
 	src/model/DescribeUserStatusRequest.cc
 	src/model/DescribeUserStatusResult.cc
+	src/model/DisableUserConfigRequest.cc
+	src/model/DisableUserConfigResult.cc
 	src/model/ExecDatamaskRequest.cc
 	src/model/ExecDatamaskResult.cc
 	src/model/ManualTriggerMaskingProcessRequest.cc
@@ -208,10 +206,8 @@ set(sddp_src
 	src/model/ModifyRuleResult.cc
 	src/model/ModifyRuleStatusRequest.cc
 	src/model/ModifyRuleStatusResult.cc
-	src/model/ModifySaleFlowCountTypeRequest.cc
-	src/model/ModifySaleFlowCountTypeResult.cc
-	src/model/ValidateConnectorRequest.cc
-	src/model/ValidateConnectorResult.cc )
+	src/model/StopMaskingProcessRequest.cc
+	src/model/StopMaskingProcessResult.cc )
 
 add_library(sddp ${LIB_TYPE}
 	${sddp_public_header}

sddp/include/alibabacloud/sddp/SddpClient.h

@@ -22,14 +22,16 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "SddpExport.h"
+#include "model/BatchDeleteDataLimitRequest.h"
+#include "model/BatchDeleteDataLimitResult.h"
 #include "model/CreateConfigRequest.h"
 #include "model/CreateConfigResult.h"
 #include "model/CreateDataLimitRequest.h"
 #include "model/CreateDataLimitResult.h"
 #include "model/CreateRuleRequest.h"
 #include "model/CreateRuleResult.h"
-#include "model/CreateUserAuthRequest.h"
-#include "model/CreateUserAuthResult.h"
+#include "model/CreateScanTaskRequest.h"
+#include "model/CreateScanTaskResult.h"
 #include "model/DeleteDataLimitRequest.h"
 #include "model/DeleteDataLimitResult.h"
 #include "model/DeleteRuleRequest.h"
@@ -38,64 +40,62 @@
 #include "model/DescribeAccountDetailResult.h"
 #include "model/DescribeAccountsRequest.h"
 #include "model/DescribeAccountsResult.h"
-#include "model/DescribeAuditLogsRequest.h"
-#include "model/DescribeAuditLogsResult.h"
-#include "model/DescribeAuthAccountsRequest.h"
-#include "model/DescribeAuthAccountsResult.h"
-#include "model/DescribeCloudDatabasesRequest.h"
-#include "model/DescribeCloudDatabasesResult.h"
-#include "model/DescribeCloudInstancesRequest.h"
-#include "model/DescribeCloudInstancesResult.h"
 #include "model/DescribeColumnsRequest.h"
 #include "model/DescribeColumnsResult.h"
 #include "model/DescribeConfigsRequest.h"
 #include "model/DescribeConfigsResult.h"
 #include "model/DescribeDataAssetsRequest.h"
 #include "model/DescribeDataAssetsResult.h"
-#include "model/DescribeDataHubConnectorsRequest.h"
-#include "model/DescribeDataHubConnectorsResult.h"
-#include "model/DescribeDataHubProjectsRequest.h"
-#include "model/DescribeDataHubProjectsResult.h"
-#include "model/DescribeDataHubSubscriptionsRequest.h"
-#include "model/DescribeDataHubSubscriptionsResult.h"
-#include "model/DescribeDataHubTopicsRequest.h"
-#include "model/DescribeDataHubTopicsResult.h"
 #include "model/DescribeDataLimitDetailRequest.h"
 #include "model/DescribeDataLimitDetailResult.h"
+#include "model/DescribeDataLimitSetRequest.h"
+#include "model/DescribeDataLimitSetResult.h"
 #include "model/DescribeDataLimitsRequest.h"
 #include "model/DescribeDataLimitsResult.h"
+#include "model/DescribeDataLimitsInstanceDimRequest.h"
+#include "model/DescribeDataLimitsInstanceDimResult.h"
 #include "model/DescribeDataMaskingRunHistoryRequest.h"
 #include "model/DescribeDataMaskingRunHistoryResult.h"
 #include "model/DescribeDataMaskingTasksRequest.h"
 #include "model/DescribeDataMaskingTasksResult.h"
-#include "model/DescribeDepartsRequest.h"
-#include "model/DescribeDepartsResult.h"
+#include "model/DescribeDataTotalCountRequest.h"
+#include "model/DescribeDataTotalCountResult.h"
 #include "model/DescribeEventDetailRequest.h"
 #include "model/DescribeEventDetailResult.h"
+#include "model/DescribeEventTopRequest.h"
+#include "model/DescribeEventTopResult.h"
 #include "model/DescribeEventTypesRequest.h"
 #include "model/DescribeEventTypesResult.h"
+#include "model/DescribeEventTypesDetailRequest.h"
+#include "model/DescribeEventTypesDetailResult.h"
 #include "model/DescribeEventsRequest.h"
 #include "model/DescribeEventsResult.h"
+#include "model/DescribeInstancePortraitRequest.h"
+#include "model/DescribeInstancePortraitResult.h"
+#include "model/DescribeInstanceSourcesRequest.h"
+#include "model/DescribeInstanceSourcesResult.h"
 #include "model/DescribeInstancesRequest.h"
 #include "model/DescribeInstancesResult.h"
-#include "model/DescribeOriginalLogsRequest.h"
-#include "model/DescribeOriginalLogsResult.h"
 #include "model/DescribeOssObjectDetailRequest.h"
 #include "model/DescribeOssObjectDetailResult.h"
 #include "model/DescribeOssObjectsRequest.h"
 #include "model/DescribeOssObjectsResult.h"
 #include "model/DescribePackagesRequest.h"
 #include "model/DescribePackagesResult.h"
-#include "model/DescribePrivilegesRequest.h"
-#include "model/DescribePrivilegesResult.h"
+#include "model/DescribeRiskLevelsRequest.h"
+#include "model/DescribeRiskLevelsResult.h"
+#include "model/DescribeRuleCategoryRequest.h"
+#include "model/DescribeRuleCategoryResult.h"
 #include "model/DescribeRulesRequest.h"
 #include "model/DescribeRulesResult.h"
 #include "model/DescribeTablesRequest.h"
 #include "model/DescribeTablesResult.h"
-#include "model/DescribeUseFlowRequest.h"
-#include "model/DescribeUseFlowResult.h"
+#include "model/DescribeUserCountRequest.h"
+#include "model/DescribeUserCountResult.h"
 #include "model/DescribeUserStatusRequest.h"
 #include "model/DescribeUserStatusResult.h"
+#include "model/DisableUserConfigRequest.h"
+#include "model/DisableUserConfigResult.h"
 #include "model/ExecDatamaskRequest.h"
 #include "model/ExecDatamaskResult.h"
 #include "model/ManualTriggerMaskingProcessRequest.h"
@@ -112,10 +112,8 @@
 #include "model/ModifyRuleResult.h"
 #include "model/ModifyRuleStatusRequest.h"
 #include "model/ModifyRuleStatusResult.h"
-#include "model/ModifySaleFlowCountTypeRequest.h"
-#include "model/ModifySaleFlowCountTypeResult.h"
-#include "model/ValidateConnectorRequest.h"
-#include "model/ValidateConnectorResult.h"
+#include "model/StopMaskingProcessRequest.h"
+#include "model/StopMaskingProcessResult.h"
 
 
 namespace AlibabaCloud
@@ -125,6 +123,9 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_SDDP_EXPORT SddpClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::BatchDeleteDataLimitResult> BatchDeleteDataLimitOutcome;
+			typedef std::future<BatchDeleteDataLimitOutcome> BatchDeleteDataLimitOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::BatchDeleteDataLimitRequest&, const BatchDeleteDataLimitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchDeleteDataLimitAsyncHandler;
 			typedef Outcome<Error, Model::CreateConfigResult> CreateConfigOutcome;
 			typedef std::future<CreateConfigOutcome> CreateConfigOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::CreateConfigRequest&, const CreateConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateConfigAsyncHandler;
@@ -134,9 +135,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateRuleResult> CreateRuleOutcome;
 			typedef std::future<CreateRuleOutcome> CreateRuleOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::CreateRuleRequest&, const CreateRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRuleAsyncHandler;
-			typedef Outcome<Error, Model::CreateUserAuthResult> CreateUserAuthOutcome;
-			typedef std::future<CreateUserAuthOutcome> CreateUserAuthOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::CreateUserAuthRequest&, const CreateUserAuthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateUserAuthAsyncHandler;
+			typedef Outcome<Error, Model::CreateScanTaskResult> CreateScanTaskOutcome;
+			typedef std::future<CreateScanTaskOutcome> CreateScanTaskOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::CreateScanTaskRequest&, const CreateScanTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScanTaskAsyncHandler;
 			typedef Outcome<Error, Model::DeleteDataLimitResult> DeleteDataLimitOutcome;
 			typedef std::future<DeleteDataLimitOutcome> DeleteDataLimitOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DeleteDataLimitRequest&, const DeleteDataLimitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDataLimitAsyncHandler;
@@ -149,18 +150,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeAccountsResult> DescribeAccountsOutcome;
 			typedef std::future<DescribeAccountsOutcome> DescribeAccountsOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeAccountsRequest&, const DescribeAccountsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountsAsyncHandler;
-			typedef Outcome<Error, Model::DescribeAuditLogsResult> DescribeAuditLogsOutcome;
-			typedef std::future<DescribeAuditLogsOutcome> DescribeAuditLogsOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeAuditLogsRequest&, const DescribeAuditLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAuditLogsAsyncHandler;
-			typedef Outcome<Error, Model::DescribeAuthAccountsResult> DescribeAuthAccountsOutcome;
-			typedef std::future<DescribeAuthAccountsOutcome> DescribeAuthAccountsOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeAuthAccountsRequest&, const DescribeAuthAccountsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAuthAccountsAsyncHandler;
-			typedef Outcome<Error, Model::DescribeCloudDatabasesResult> DescribeCloudDatabasesOutcome;
-			typedef std::future<DescribeCloudDatabasesOutcome> DescribeCloudDatabasesOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeCloudDatabasesRequest&, const DescribeCloudDatabasesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCloudDatabasesAsyncHandler;
-			typedef Outcome<Error, Model::DescribeCloudInstancesResult> DescribeCloudInstancesOutcome;
-			typedef std::future<DescribeCloudInstancesOutcome> DescribeCloudInstancesOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeCloudInstancesRequest&, const DescribeCloudInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCloudInstancesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeColumnsResult> DescribeColumnsOutcome;
 			typedef std::future<DescribeColumnsOutcome> DescribeColumnsOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeColumnsRequest&, const DescribeColumnsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeColumnsAsyncHandler;
@@ -170,48 +159,51 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDataAssetsResult> DescribeDataAssetsOutcome;
 			typedef std::future<DescribeDataAssetsOutcome> DescribeDataAssetsOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeDataAssetsRequest&, const DescribeDataAssetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataAssetsAsyncHandler;
-			typedef Outcome<Error, Model::DescribeDataHubConnectorsResult> DescribeDataHubConnectorsOutcome;
-			typedef std::future<DescribeDataHubConnectorsOutcome> DescribeDataHubConnectorsOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeDataHubConnectorsRequest&, const DescribeDataHubConnectorsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataHubConnectorsAsyncHandler;
-			typedef Outcome<Error, Model::DescribeDataHubProjectsResult> DescribeDataHubProjectsOutcome;
-			typedef std::future<DescribeDataHubProjectsOutcome> DescribeDataHubProjectsOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeDataHubProjectsRequest&, const DescribeDataHubProjectsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataHubProjectsAsyncHandler;
-			typedef Outcome<Error, Model::DescribeDataHubSubscriptionsResult> DescribeDataHubSubscriptionsOutcome;
-			typedef std::future<DescribeDataHubSubscriptionsOutcome> DescribeDataHubSubscriptionsOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeDataHubSubscriptionsRequest&, const DescribeDataHubSubscriptionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataHubSubscriptionsAsyncHandler;
-			typedef Outcome<Error, Model::DescribeDataHubTopicsResult> DescribeDataHubTopicsOutcome;
-			typedef std::future<DescribeDataHubTopicsOutcome> DescribeDataHubTopicsOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeDataHubTopicsRequest&, const DescribeDataHubTopicsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataHubTopicsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDataLimitDetailResult> DescribeDataLimitDetailOutcome;
 			typedef std::future<DescribeDataLimitDetailOutcome> DescribeDataLimitDetailOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeDataLimitDetailRequest&, const DescribeDataLimitDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataLimitDetailAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDataLimitSetResult> DescribeDataLimitSetOutcome;
+			typedef std::future<DescribeDataLimitSetOutcome> DescribeDataLimitSetOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeDataLimitSetRequest&, const DescribeDataLimitSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataLimitSetAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDataLimitsResult> DescribeDataLimitsOutcome;
 			typedef std::future<DescribeDataLimitsOutcome> DescribeDataLimitsOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeDataLimitsRequest&, const DescribeDataLimitsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataLimitsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDataLimitsInstanceDimResult> DescribeDataLimitsInstanceDimOutcome;
+			typedef std::future<DescribeDataLimitsInstanceDimOutcome> DescribeDataLimitsInstanceDimOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeDataLimitsInstanceDimRequest&, const DescribeDataLimitsInstanceDimOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataLimitsInstanceDimAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDataMaskingRunHistoryResult> DescribeDataMaskingRunHistoryOutcome;
 			typedef std::future<DescribeDataMaskingRunHistoryOutcome> DescribeDataMaskingRunHistoryOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeDataMaskingRunHistoryRequest&, const DescribeDataMaskingRunHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataMaskingRunHistoryAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDataMaskingTasksResult> DescribeDataMaskingTasksOutcome;
 			typedef std::future<DescribeDataMaskingTasksOutcome> DescribeDataMaskingTasksOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeDataMaskingTasksRequest&, const DescribeDataMaskingTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataMaskingTasksAsyncHandler;
-			typedef Outcome<Error, Model::DescribeDepartsResult> DescribeDepartsOutcome;
-			typedef std::future<DescribeDepartsOutcome> DescribeDepartsOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeDepartsRequest&, const DescribeDepartsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDepartsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDataTotalCountResult> DescribeDataTotalCountOutcome;
+			typedef std::future<DescribeDataTotalCountOutcome> DescribeDataTotalCountOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeDataTotalCountRequest&, const DescribeDataTotalCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataTotalCountAsyncHandler;
 			typedef Outcome<Error, Model::DescribeEventDetailResult> DescribeEventDetailOutcome;
 			typedef std::future<DescribeEventDetailOutcome> DescribeEventDetailOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeEventDetailRequest&, const DescribeEventDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEventDetailAsyncHandler;
+			typedef Outcome<Error, Model::DescribeEventTopResult> DescribeEventTopOutcome;
+			typedef std::future<DescribeEventTopOutcome> DescribeEventTopOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeEventTopRequest&, const DescribeEventTopOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEventTopAsyncHandler;
 			typedef Outcome<Error, Model::DescribeEventTypesResult> DescribeEventTypesOutcome;
 			typedef std::future<DescribeEventTypesOutcome> DescribeEventTypesOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeEventTypesRequest&, const DescribeEventTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEventTypesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeEventTypesDetailResult> DescribeEventTypesDetailOutcome;
+			typedef std::future<DescribeEventTypesDetailOutcome> DescribeEventTypesDetailOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeEventTypesDetailRequest&, const DescribeEventTypesDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEventTypesDetailAsyncHandler;
 			typedef Outcome<Error, Model::DescribeEventsResult> DescribeEventsOutcome;
 			typedef std::future<DescribeEventsOutcome> DescribeEventsOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeEventsRequest&, const DescribeEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEventsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeInstancePortraitResult> DescribeInstancePortraitOutcome;
+			typedef std::future<DescribeInstancePortraitOutcome> DescribeInstancePortraitOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeInstancePortraitRequest&, const DescribeInstancePortraitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstancePortraitAsyncHandler;
+			typedef Outcome<Error, Model::DescribeInstanceSourcesResult> DescribeInstanceSourcesOutcome;
+			typedef std::future<DescribeInstanceSourcesOutcome> DescribeInstanceSourcesOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeInstanceSourcesRequest&, const DescribeInstanceSourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceSourcesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeInstancesResult> DescribeInstancesOutcome;
 			typedef std::future<DescribeInstancesOutcome> DescribeInstancesOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeInstancesRequest&, const DescribeInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstancesAsyncHandler;
-			typedef Outcome<Error, Model::DescribeOriginalLogsResult> DescribeOriginalLogsOutcome;
-			typedef std::future<DescribeOriginalLogsOutcome> DescribeOriginalLogsOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeOriginalLogsRequest&, const DescribeOriginalLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOriginalLogsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeOssObjectDetailResult> DescribeOssObjectDetailOutcome;
 			typedef std::future<DescribeOssObjectDetailOutcome> DescribeOssObjectDetailOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeOssObjectDetailRequest&, const DescribeOssObjectDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOssObjectDetailAsyncHandler;
@@ -221,21 +213,27 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribePackagesResult> DescribePackagesOutcome;
 			typedef std::future<DescribePackagesOutcome> DescribePackagesOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribePackagesRequest&, const DescribePackagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePackagesAsyncHandler;
-			typedef Outcome<Error, Model::DescribePrivilegesResult> DescribePrivilegesOutcome;
-			typedef std::future<DescribePrivilegesOutcome> DescribePrivilegesOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribePrivilegesRequest&, const DescribePrivilegesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePrivilegesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRiskLevelsResult> DescribeRiskLevelsOutcome;
+			typedef std::future<DescribeRiskLevelsOutcome> DescribeRiskLevelsOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeRiskLevelsRequest&, const DescribeRiskLevelsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRiskLevelsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRuleCategoryResult> DescribeRuleCategoryOutcome;
+			typedef std::future<DescribeRuleCategoryOutcome> DescribeRuleCategoryOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeRuleCategoryRequest&, const DescribeRuleCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRuleCategoryAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRulesResult> DescribeRulesOutcome;
 			typedef std::future<DescribeRulesOutcome> DescribeRulesOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeRulesRequest&, const DescribeRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRulesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeTablesResult> DescribeTablesOutcome;
 			typedef std::future<DescribeTablesOutcome> DescribeTablesOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeTablesRequest&, const DescribeTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTablesAsyncHandler;
-			typedef Outcome<Error, Model::DescribeUseFlowResult> DescribeUseFlowOutcome;
-			typedef std::future<DescribeUseFlowOutcome> DescribeUseFlowOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::DescribeUseFlowRequest&, const DescribeUseFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUseFlowAsyncHandler;
+			typedef Outcome<Error, Model::DescribeUserCountResult> DescribeUserCountOutcome;
+			typedef std::future<DescribeUserCountOutcome> DescribeUserCountOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DescribeUserCountRequest&, const DescribeUserCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserCountAsyncHandler;
 			typedef Outcome<Error, Model::DescribeUserStatusResult> DescribeUserStatusOutcome;
 			typedef std::future<DescribeUserStatusOutcome> DescribeUserStatusOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::DescribeUserStatusRequest&, const DescribeUserStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserStatusAsyncHandler;
+			typedef Outcome<Error, Model::DisableUserConfigResult> DisableUserConfigOutcome;
+			typedef std::future<DisableUserConfigOutcome> DisableUserConfigOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::DisableUserConfigRequest&, const DisableUserConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableUserConfigAsyncHandler;
 			typedef Outcome<Error, Model::ExecDatamaskResult> ExecDatamaskOutcome;
 			typedef std::future<ExecDatamaskOutcome> ExecDatamaskOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::ExecDatamaskRequest&, const ExecDatamaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExecDatamaskAsyncHandler;
@@ -260,17 +258,17 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyRuleStatusResult> ModifyRuleStatusOutcome;
 			typedef std::future<ModifyRuleStatusOutcome> ModifyRuleStatusOutcomeCallable;
 			typedef std::function<void(const SddpClient*, const Model::ModifyRuleStatusRequest&, const ModifyRuleStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyRuleStatusAsyncHandler;
-			typedef Outcome<Error, Model::ModifySaleFlowCountTypeResult> ModifySaleFlowCountTypeOutcome;
-			typedef std::future<ModifySaleFlowCountTypeOutcome> ModifySaleFlowCountTypeOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::ModifySaleFlowCountTypeRequest&, const ModifySaleFlowCountTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifySaleFlowCountTypeAsyncHandler;
-			typedef Outcome<Error, Model::ValidateConnectorResult> ValidateConnectorOutcome;
-			typedef std::future<ValidateConnectorOutcome> ValidateConnectorOutcomeCallable;
-			typedef std::function<void(const SddpClient*, const Model::ValidateConnectorRequest&, const ValidateConnectorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateConnectorAsyncHandler;
+			typedef Outcome<Error, Model::StopMaskingProcessResult> StopMaskingProcessOutcome;
+			typedef std::future<StopMaskingProcessOutcome> StopMaskingProcessOutcomeCallable;
+			typedef std::function<void(const SddpClient*, const Model::StopMaskingProcessRequest&, const StopMaskingProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopMaskingProcessAsyncHandler;
 
 			SddpClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			SddpClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			SddpClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~SddpClient();
+			BatchDeleteDataLimitOutcome batchDeleteDataLimit(const Model::BatchDeleteDataLimitRequest &request)const;
+			void batchDeleteDataLimitAsync(const Model::BatchDeleteDataLimitRequest& request, const BatchDeleteDataLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BatchDeleteDataLimitOutcomeCallable batchDeleteDataLimitCallable(const Model::BatchDeleteDataLimitRequest& request) const;
 			CreateConfigOutcome createConfig(const Model::CreateConfigRequest &request)const;
 			void createConfigAsync(const Model::CreateConfigRequest& request, const CreateConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateConfigOutcomeCallable createConfigCallable(const Model::CreateConfigRequest& request) const;
@@ -280,9 +278,9 @@ namespace AlibabaCloud
 			CreateRuleOutcome createRule(const Model::CreateRuleRequest &request)const;
 			void createRuleAsync(const Model::CreateRuleRequest& request, const CreateRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateRuleOutcomeCallable createRuleCallable(const Model::CreateRuleRequest& request) const;
-			CreateUserAuthOutcome createUserAuth(const Model::CreateUserAuthRequest &request)const;
-			void createUserAuthAsync(const Model::CreateUserAuthRequest& request, const CreateUserAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateUserAuthOutcomeCallable createUserAuthCallable(const Model::CreateUserAuthRequest& request) const;
+			CreateScanTaskOutcome createScanTask(const Model::CreateScanTaskRequest &request)const;
+			void createScanTaskAsync(const Model::CreateScanTaskRequest& request, const CreateScanTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateScanTaskOutcomeCallable createScanTaskCallable(const Model::CreateScanTaskRequest& request) const;
 			DeleteDataLimitOutcome deleteDataLimit(const Model::DeleteDataLimitRequest &request)const;
 			void deleteDataLimitAsync(const Model::DeleteDataLimitRequest& request, const DeleteDataLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDataLimitOutcomeCallable deleteDataLimitCallable(const Model::DeleteDataLimitRequest& request) const;
@@ -295,18 +293,6 @@ namespace AlibabaCloud
 			DescribeAccountsOutcome describeAccounts(const Model::DescribeAccountsRequest &request)const;
 			void describeAccountsAsync(const Model::DescribeAccountsRequest& request, const DescribeAccountsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeAccountsOutcomeCallable describeAccountsCallable(const Model::DescribeAccountsRequest& request) const;
-			DescribeAuditLogsOutcome describeAuditLogs(const Model::DescribeAuditLogsRequest &request)const;
-			void describeAuditLogsAsync(const Model::DescribeAuditLogsRequest& request, const DescribeAuditLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeAuditLogsOutcomeCallable describeAuditLogsCallable(const Model::DescribeAuditLogsRequest& request) const;
-			DescribeAuthAccountsOutcome describeAuthAccounts(const Model::DescribeAuthAccountsRequest &request)const;
-			void describeAuthAccountsAsync(const Model::DescribeAuthAccountsRequest& request, const DescribeAuthAccountsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeAuthAccountsOutcomeCallable describeAuthAccountsCallable(const Model::DescribeAuthAccountsRequest& request) const;
-			DescribeCloudDatabasesOutcome describeCloudDatabases(const Model::DescribeCloudDatabasesRequest &request)const;
-			void describeCloudDatabasesAsync(const Model::DescribeCloudDatabasesRequest& request, const DescribeCloudDatabasesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeCloudDatabasesOutcomeCallable describeCloudDatabasesCallable(const Model::DescribeCloudDatabasesRequest& request) const;
-			DescribeCloudInstancesOutcome describeCloudInstances(const Model::DescribeCloudInstancesRequest &request)const;
-			void describeCloudInstancesAsync(const Model::DescribeCloudInstancesRequest& request, const DescribeCloudInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeCloudInstancesOutcomeCallable describeCloudInstancesCallable(const Model::DescribeCloudInstancesRequest& request) const;
 			DescribeColumnsOutcome describeColumns(const Model::DescribeColumnsRequest &request)const;
 			void describeColumnsAsync(const Model::DescribeColumnsRequest& request, const DescribeColumnsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeColumnsOutcomeCallable describeColumnsCallable(const Model::DescribeColumnsRequest& request) const;
@@ -316,48 +302,51 @@ namespace AlibabaCloud
 			DescribeDataAssetsOutcome describeDataAssets(const Model::DescribeDataAssetsRequest &request)const;
 			void describeDataAssetsAsync(const Model::DescribeDataAssetsRequest& request, const DescribeDataAssetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDataAssetsOutcomeCallable describeDataAssetsCallable(const Model::DescribeDataAssetsRequest& request) const;
-			DescribeDataHubConnectorsOutcome describeDataHubConnectors(const Model::DescribeDataHubConnectorsRequest &request)const;
-			void describeDataHubConnectorsAsync(const Model::DescribeDataHubConnectorsRequest& request, const DescribeDataHubConnectorsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeDataHubConnectorsOutcomeCallable describeDataHubConnectorsCallable(const Model::DescribeDataHubConnectorsRequest& request) const;
-			DescribeDataHubProjectsOutcome describeDataHubProjects(const Model::DescribeDataHubProjectsRequest &request)const;
-			void describeDataHubProjectsAsync(const Model::DescribeDataHubProjectsRequest& request, const DescribeDataHubProjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeDataHubProjectsOutcomeCallable describeDataHubProjectsCallable(const Model::DescribeDataHubProjectsRequest& request) const;
-			DescribeDataHubSubscriptionsOutcome describeDataHubSubscriptions(const Model::DescribeDataHubSubscriptionsRequest &request)const;
-			void describeDataHubSubscriptionsAsync(const Model::DescribeDataHubSubscriptionsRequest& request, const DescribeDataHubSubscriptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeDataHubSubscriptionsOutcomeCallable describeDataHubSubscriptionsCallable(const Model::DescribeDataHubSubscriptionsRequest& request) const;
-			DescribeDataHubTopicsOutcome describeDataHubTopics(const Model::DescribeDataHubTopicsRequest &request)const;
-			void describeDataHubTopicsAsync(const Model::DescribeDataHubTopicsRequest& request, const DescribeDataHubTopicsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeDataHubTopicsOutcomeCallable describeDataHubTopicsCallable(const Model::DescribeDataHubTopicsRequest& request) const;
 			DescribeDataLimitDetailOutcome describeDataLimitDetail(const Model::DescribeDataLimitDetailRequest &request)const;
 			void describeDataLimitDetailAsync(const Model::DescribeDataLimitDetailRequest& request, const DescribeDataLimitDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDataLimitDetailOutcomeCallable describeDataLimitDetailCallable(const Model::DescribeDataLimitDetailRequest& request) const;
+			DescribeDataLimitSetOutcome describeDataLimitSet(const Model::DescribeDataLimitSetRequest &request)const;
+			void describeDataLimitSetAsync(const Model::DescribeDataLimitSetRequest& request, const DescribeDataLimitSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDataLimitSetOutcomeCallable describeDataLimitSetCallable(const Model::DescribeDataLimitSetRequest& request) const;
 			DescribeDataLimitsOutcome describeDataLimits(const Model::DescribeDataLimitsRequest &request)const;
 			void describeDataLimitsAsync(const Model::DescribeDataLimitsRequest& request, const DescribeDataLimitsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDataLimitsOutcomeCallable describeDataLimitsCallable(const Model::DescribeDataLimitsRequest& request) const;
+			DescribeDataLimitsInstanceDimOutcome describeDataLimitsInstanceDim(const Model::DescribeDataLimitsInstanceDimRequest &request)const;
+			void describeDataLimitsInstanceDimAsync(const Model::DescribeDataLimitsInstanceDimRequest& request, const DescribeDataLimitsInstanceDimAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDataLimitsInstanceDimOutcomeCallable describeDataLimitsInstanceDimCallable(const Model::DescribeDataLimitsInstanceDimRequest& request) const;
 			DescribeDataMaskingRunHistoryOutcome describeDataMaskingRunHistory(const Model::DescribeDataMaskingRunHistoryRequest &request)const;
 			void describeDataMaskingRunHistoryAsync(const Model::DescribeDataMaskingRunHistoryRequest& request, const DescribeDataMaskingRunHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDataMaskingRunHistoryOutcomeCallable describeDataMaskingRunHistoryCallable(const Model::DescribeDataMaskingRunHistoryRequest& request) const;
 			DescribeDataMaskingTasksOutcome describeDataMaskingTasks(const Model::DescribeDataMaskingTasksRequest &request)const;
 			void describeDataMaskingTasksAsync(const Model::DescribeDataMaskingTasksRequest& request, const DescribeDataMaskingTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDataMaskingTasksOutcomeCallable describeDataMaskingTasksCallable(const Model::DescribeDataMaskingTasksRequest& request) const;
-			DescribeDepartsOutcome describeDeparts(const Model::DescribeDepartsRequest &request)const;
-			void describeDepartsAsync(const Model::DescribeDepartsRequest& request, const DescribeDepartsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeDepartsOutcomeCallable describeDepartsCallable(const Model::DescribeDepartsRequest& request) const;
+			DescribeDataTotalCountOutcome describeDataTotalCount(const Model::DescribeDataTotalCountRequest &request)const;
+			void describeDataTotalCountAsync(const Model::DescribeDataTotalCountRequest& request, const DescribeDataTotalCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDataTotalCountOutcomeCallable describeDataTotalCountCallable(const Model::DescribeDataTotalCountRequest& request) const;
 			DescribeEventDetailOutcome describeEventDetail(const Model::DescribeEventDetailRequest &request)const;
 			void describeEventDetailAsync(const Model::DescribeEventDetailRequest& request, const DescribeEventDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeEventDetailOutcomeCallable describeEventDetailCallable(const Model::DescribeEventDetailRequest& request) const;
+			DescribeEventTopOutcome describeEventTop(const Model::DescribeEventTopRequest &request)const;
+			void describeEventTopAsync(const Model::DescribeEventTopRequest& request, const DescribeEventTopAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeEventTopOutcomeCallable describeEventTopCallable(const Model::DescribeEventTopRequest& request) const;
 			DescribeEventTypesOutcome describeEventTypes(const Model::DescribeEventTypesRequest &request)const;
 			void describeEventTypesAsync(const Model::DescribeEventTypesRequest& request, const DescribeEventTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeEventTypesOutcomeCallable describeEventTypesCallable(const Model::DescribeEventTypesRequest& request) const;
+			DescribeEventTypesDetailOutcome describeEventTypesDetail(const Model::DescribeEventTypesDetailRequest &request)const;
+			void describeEventTypesDetailAsync(const Model::DescribeEventTypesDetailRequest& request, const DescribeEventTypesDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeEventTypesDetailOutcomeCallable describeEventTypesDetailCallable(const Model::DescribeEventTypesDetailRequest& request) const;
 			DescribeEventsOutcome describeEvents(const Model::DescribeEventsRequest &request)const;
 			void describeEventsAsync(const Model::DescribeEventsRequest& request, const DescribeEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeEventsOutcomeCallable describeEventsCallable(const Model::DescribeEventsRequest& request) const;
+			DescribeInstancePortraitOutcome describeInstancePortrait(const Model::DescribeInstancePortraitRequest &request)const;
+			void describeInstancePortraitAsync(const Model::DescribeInstancePortraitRequest& request, const DescribeInstancePortraitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeInstancePortraitOutcomeCallable describeInstancePortraitCallable(const Model::DescribeInstancePortraitRequest& request) const;
+			DescribeInstanceSourcesOutcome describeInstanceSources(const Model::DescribeInstanceSourcesRequest &request)const;
+			void describeInstanceSourcesAsync(const Model::DescribeInstanceSourcesRequest& request, const DescribeInstanceSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeInstanceSourcesOutcomeCallable describeInstanceSourcesCallable(const Model::DescribeInstanceSourcesRequest& request) const;
 			DescribeInstancesOutcome describeInstances(const Model::DescribeInstancesRequest &request)const;
 			void describeInstancesAsync(const Model::DescribeInstancesRequest& request, const DescribeInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeInstancesOutcomeCallable describeInstancesCallable(const Model::DescribeInstancesRequest& request) const;
-			DescribeOriginalLogsOutcome describeOriginalLogs(const Model::DescribeOriginalLogsRequest &request)const;
-			void describeOriginalLogsAsync(const Model::DescribeOriginalLogsRequest& request, const DescribeOriginalLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeOriginalLogsOutcomeCallable describeOriginalLogsCallable(const Model::DescribeOriginalLogsRequest& request) const;
 			DescribeOssObjectDetailOutcome describeOssObjectDetail(const Model::DescribeOssObjectDetailRequest &request)const;
 			void describeOssObjectDetailAsync(const Model::DescribeOssObjectDetailRequest& request, const DescribeOssObjectDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeOssObjectDetailOutcomeCallable describeOssObjectDetailCallable(const Model::DescribeOssObjectDetailRequest& request) const;
@@ -367,21 +356,27 @@ namespace AlibabaCloud
 			DescribePackagesOutcome describePackages(const Model::DescribePackagesRequest &request)const;
 			void describePackagesAsync(const Model::DescribePackagesRequest& request, const DescribePackagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribePackagesOutcomeCallable describePackagesCallable(const Model::DescribePackagesRequest& request) const;
-			DescribePrivilegesOutcome describePrivileges(const Model::DescribePrivilegesRequest &request)const;
-			void describePrivilegesAsync(const Model::DescribePrivilegesRequest& request, const DescribePrivilegesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribePrivilegesOutcomeCallable describePrivilegesCallable(const Model::DescribePrivilegesRequest& request) const;
+			DescribeRiskLevelsOutcome describeRiskLevels(const Model::DescribeRiskLevelsRequest &request)const;
+			void describeRiskLevelsAsync(const Model::DescribeRiskLevelsRequest& request, const DescribeRiskLevelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRiskLevelsOutcomeCallable describeRiskLevelsCallable(const Model::DescribeRiskLevelsRequest& request) const;
+			DescribeRuleCategoryOutcome describeRuleCategory(const Model::DescribeRuleCategoryRequest &request)const;
+			void describeRuleCategoryAsync(const Model::DescribeRuleCategoryRequest& request, const DescribeRuleCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRuleCategoryOutcomeCallable describeRuleCategoryCallable(const Model::DescribeRuleCategoryRequest& request) const;
 			DescribeRulesOutcome describeRules(const Model::DescribeRulesRequest &request)const;
 			void describeRulesAsync(const Model::DescribeRulesRequest& request, const DescribeRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRulesOutcomeCallable describeRulesCallable(const Model::DescribeRulesRequest& request) const;
 			DescribeTablesOutcome describeTables(const Model::DescribeTablesRequest &request)const;
 			void describeTablesAsync(const Model::DescribeTablesRequest& request, const DescribeTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeTablesOutcomeCallable describeTablesCallable(const Model::DescribeTablesRequest& request) const;
-			DescribeUseFlowOutcome describeUseFlow(const Model::DescribeUseFlowRequest &request)const;
-			void describeUseFlowAsync(const Model::DescribeUseFlowRequest& request, const DescribeUseFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeUseFlowOutcomeCallable describeUseFlowCallable(const Model::DescribeUseFlowRequest& request) const;
+			DescribeUserCountOutcome describeUserCount(const Model::DescribeUserCountRequest &request)const;
+			void describeUserCountAsync(const Model::DescribeUserCountRequest& request, const DescribeUserCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeUserCountOutcomeCallable describeUserCountCallable(const Model::DescribeUserCountRequest& request) const;
 			DescribeUserStatusOutcome describeUserStatus(const Model::DescribeUserStatusRequest &request)const;
 			void describeUserStatusAsync(const Model::DescribeUserStatusRequest& request, const DescribeUserStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeUserStatusOutcomeCallable describeUserStatusCallable(const Model::DescribeUserStatusRequest& request) const;
+			DisableUserConfigOutcome disableUserConfig(const Model::DisableUserConfigRequest &request)const;
+			void disableUserConfigAsync(const Model::DisableUserConfigRequest& request, const DisableUserConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableUserConfigOutcomeCallable disableUserConfigCallable(const Model::DisableUserConfigRequest& request) const;
 			ExecDatamaskOutcome execDatamask(const Model::ExecDatamaskRequest &request)const;
 			void execDatamaskAsync(const Model::ExecDatamaskRequest& request, const ExecDatamaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExecDatamaskOutcomeCallable execDatamaskCallable(const Model::ExecDatamaskRequest& request) const;
@@ -406,12 +401,9 @@ namespace AlibabaCloud
 			ModifyRuleStatusOutcome modifyRuleStatus(const Model::ModifyRuleStatusRequest &request)const;
 			void modifyRuleStatusAsync(const Model::ModifyRuleStatusRequest& request, const ModifyRuleStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyRuleStatusOutcomeCallable modifyRuleStatusCallable(const Model::ModifyRuleStatusRequest& request) const;
-			ModifySaleFlowCountTypeOutcome modifySaleFlowCountType(const Model::ModifySaleFlowCountTypeRequest &request)const;
-			void modifySaleFlowCountTypeAsync(const Model::ModifySaleFlowCountTypeRequest& request, const ModifySaleFlowCountTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifySaleFlowCountTypeOutcomeCallable modifySaleFlowCountTypeCallable(const Model::ModifySaleFlowCountTypeRequest& request) const;
-			ValidateConnectorOutcome validateConnector(const Model::ValidateConnectorRequest &request)const;
-			void validateConnectorAsync(const Model::ValidateConnectorRequest& request, const ValidateConnectorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ValidateConnectorOutcomeCallable validateConnectorCallable(const Model::ValidateConnectorRequest& request) const;
+			StopMaskingProcessOutcome stopMaskingProcess(const Model::StopMaskingProcessRequest &request)const;
+			void stopMaskingProcessAsync(const Model::StopMaskingProcessRequest& request, const StopMaskingProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopMaskingProcessOutcomeCallable stopMaskingProcessCallable(const Model::StopMaskingProcessRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

sddp/include/alibabacloud/sddp/model/BatchDeleteDataLimitRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDINSTANCESREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDINSTANCESREQUEST_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_BATCHDELETEDATALIMITREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_BATCHDELETEDATALIMITREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,30 +28,27 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeCloudInstancesRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SDDP_EXPORT BatchDeleteDataLimitRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeCloudInstancesRequest();
-				~DescribeCloudInstancesRequest();
+				BatchDeleteDataLimitRequest();
+				~BatchDeleteDataLimitRequest();
 
 				long getResourceType()const;
 				void setResourceType(long resourceType);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
-				std::string getLang()const;
-				void setLang(const std::string& lang);
-				std::string getServiceRegionId()const;
-				void setServiceRegionId(const std::string& serviceRegionId);
+				std::string getDataLimitList()const;
+				void setDataLimitList(const std::string& dataLimitList);
 
             private:
 				long resourceType_;
 				std::string sourceIp_;
-				std::string lang_;
-				std::string serviceRegionId_;
+				std::string dataLimitList_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDINSTANCESREQUEST_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_BATCHDELETEDATALIMITREQUEST_H_

sddp/include/alibabacloud/sddp/model/BatchDeleteDataLimitResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_MODIFYSALEFLOWCOUNTTYPERESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_MODIFYSALEFLOWCOUNTTYPERESULT_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_BATCHDELETEDATALIMITRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_BATCHDELETEDATALIMITRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT ModifySaleFlowCountTypeResult : public ServiceResult
+			class ALIBABACLOUD_SDDP_EXPORT BatchDeleteDataLimitResult : public ServiceResult
 			{
 			public:
 
 
-				ModifySaleFlowCountTypeResult();
-				explicit ModifySaleFlowCountTypeResult(const std::string &payload);
-				~ModifySaleFlowCountTypeResult();
+				BatchDeleteDataLimitResult();
+				explicit BatchDeleteDataLimitResult(const std::string &payload);
+				~BatchDeleteDataLimitResult();
 
 			protected:
 				void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_MODIFYSALEFLOWCOUNTTYPERESULT_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_BATCHDELETEDATALIMITRESULT_H_

sddp/include/alibabacloud/sddp/model/CreateConfigResult.h

@@ -37,10 +37,12 @@ namespace AlibabaCloud
 				CreateConfigResult();
 				explicit CreateConfigResult(const std::string &payload);
 				~CreateConfigResult();
+				long getId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				long id_;
 
 			};
 		}

sddp/include/alibabacloud/sddp/model/CreateDataLimitRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				CreateDataLimitRequest();
 				~CreateDataLimitRequest();
 
+				int getOcrStatus()const;
+				void setOcrStatus(int ocrStatus);
 				std::string getParentId()const;
 				void setParentId(const std::string& parentId);
 				std::string getPassword()const;
@@ -63,10 +65,13 @@ namespace AlibabaCloud
 				void setConnector(const std::string& connector);
 				int getPort()const;
 				void setPort(int port);
+				int getEventStatus()const;
+				void setEventStatus(int eventStatus);
 				std::string getUserName()const;
 				void setUserName(const std::string& userName);
 
             private:
+				int ocrStatus_;
 				std::string parentId_;
 				std::string password_;
 				bool batchCreate_;
@@ -81,6 +86,7 @@ namespace AlibabaCloud
 				int resourceType_;
 				std::string connector_;
 				int port_;
+				int eventStatus_;
 				std::string userName_;
 
 			};

sddp/include/alibabacloud/sddp/model/CreateRuleRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setProductCode(const std::string& productCode);
 				long getProductId()const;
 				void setProductId(long productId);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
 				long getRiskLevelId()const;
 				void setRiskLevelId(long riskLevelId);
 				std::string getContent()const;
@@ -55,17 +57,24 @@ namespace AlibabaCloud
 				void setRuleType(int ruleType);
 				std::string getStatExpress()const;
 				void setStatExpress(const std::string& statExpress);
+				int getContentCategory()const;
+				void setContentCategory(int contentCategory);
 				long getCustomType()const;
 				void setCustomType(long customType);
+				std::string getTarget()const;
+				void setTarget(const std::string& target);
 				std::string getName()const;
 				void setName(const std::string& name);
 				int getCategory()const;
 				void setCategory(int category);
+				int getStatus()const;
+				void setStatus(int status);
 
             private:
 				int warnLevel_;
 				std::string productCode_;
 				long productId_;
+				std::string description_;
 				long riskLevelId_;
 				std::string content_;
 				std::string sourceIp_;
@@ -73,9 +82,12 @@ namespace AlibabaCloud
 				int featureType_;
 				int ruleType_;
 				std::string statExpress_;
+				int contentCategory_;
 				long customType_;
+				std::string target_;
 				std::string name_;
 				int category_;
+				int status_;
 
 			};
 		}

sddp/include/alibabacloud/sddp/model/CreateScanTaskRequest.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SDDP_MODEL_CREATESCANTASKREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_CREATESCANTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT CreateScanTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateScanTaskRequest();
+				~CreateScanTaskRequest();
+
+				int getRunHour()const;
+				void setRunHour(int runHour);
+				std::string getScanRangeContent()const;
+				void setScanRangeContent(const std::string& scanRangeContent);
+				std::string getTaskName()const;
+				void setTaskName(const std::string& taskName);
+				long getDataLimitId()const;
+				void setDataLimitId(long dataLimitId);
+				int getRunMinute()const;
+				void setRunMinute(int runMinute);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+				int getIntervalDay()const;
+				void setIntervalDay(int intervalDay);
+				int getScanRange()const;
+				void setScanRange(int scanRange);
+				std::string getOssScanPath()const;
+				void setOssScanPath(const std::string& ossScanPath);
+				long getResourceType()const;
+				void setResourceType(long resourceType);
+				std::string getTaskUserName()const;
+				void setTaskUserName(const std::string& taskUserName);
+
+            private:
+				int runHour_;
+				std::string scanRangeContent_;
+				std::string taskName_;
+				long dataLimitId_;
+				int runMinute_;
+				std::string sourceIp_;
+				int intervalDay_;
+				int scanRange_;
+				std::string ossScanPath_;
+				long resourceType_;
+				std::string taskUserName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_CREATESCANTASKREQUEST_H_

sddp/include/alibabacloud/sddp/model/CreateScanTaskResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_CREATEUSERAUTHRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_CREATEUSERAUTHRESULT_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_CREATESCANTASKRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_CREATESCANTASKRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,21 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT CreateUserAuthResult : public ServiceResult
+			class ALIBABACLOUD_SDDP_EXPORT CreateScanTaskResult : public ServiceResult
 			{
 			public:
 
 
-				CreateUserAuthResult();
-				explicit CreateUserAuthResult(const std::string &payload);
-				~CreateUserAuthResult();
+				CreateScanTaskResult();
+				explicit CreateScanTaskResult(const std::string &payload);
+				~CreateScanTaskResult();
+				int getId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				int id_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_CREATEUSERAUTHRESULT_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_CREATESCANTASKRESULT_H_

sddp/include/alibabacloud/sddp/model/CreateUserAuthRequest.h

@@ -1,60 +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_SDDP_MODEL_CREATEUSERAUTHREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_CREATEUSERAUTHREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT CreateUserAuthRequest : public RpcServiceRequest
-			{
-
-			public:
-				CreateUserAuthRequest();
-				~CreateUserAuthRequest();
-
-				std::string getAccessKeySecret()const;
-				void setAccessKeySecret(const std::string& accessKeySecret);
-				long getAccountId()const;
-				void setAccountId(long accountId);
-				std::string getSourceIp()const;
-				void setSourceIp(const std::string& sourceIp);
-				std::string getAccessKey()const;
-				void setAccessKey(const std::string& accessKey);
-				std::string getLang()const;
-				void setLang(const std::string& lang);
-
-            private:
-				std::string accessKeySecret_;
-				long accountId_;
-				std::string sourceIp_;
-				std::string accessKey_;
-				std::string lang_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_CREATEUSERAUTHREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeAuditLogsRequest.h

@@ -1,84 +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_SDDP_MODEL_DESCRIBEAUDITLOGSREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUDITLOGSREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeAuditLogsRequest : public RpcServiceRequest
-			{
-
-			public:
-				DescribeAuditLogsRequest();
-				~DescribeAuditLogsRequest();
-
-				int getProductCode()const;
-				void setProductCode(int productCode);
-				long getProductId()const;
-				void setProductId(long productId);
-				long getStartTime()const;
-				void setStartTime(long startTime);
-				std::string getSourceIp()const;
-				void setSourceIp(const std::string& sourceIp);
-				std::string getClientIp()const;
-				void setClientIp(const std::string& clientIp);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
-				std::string getLang()const;
-				void setLang(const std::string& lang);
-				int getFeatureType()const;
-				void setFeatureType(int featureType);
-				long getEndTime()const;
-				void setEndTime(long endTime);
-				int getCurrentPage()const;
-				void setCurrentPage(int currentPage);
-				std::string getClientUa()const;
-				void setClientUa(const std::string& clientUa);
-				std::string getInstanceName()const;
-				void setInstanceName(const std::string& instanceName);
-				std::string getUserName()const;
-				void setUserName(const std::string& userName);
-
-            private:
-				int productCode_;
-				long productId_;
-				long startTime_;
-				std::string sourceIp_;
-				std::string clientIp_;
-				int pageSize_;
-				std::string lang_;
-				int featureType_;
-				long endTime_;
-				int currentPage_;
-				std::string clientUa_;
-				std::string instanceName_;
-				std::string userName_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUDITLOGSREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeAuthAccountsResult.h

@@ -1,66 +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_SDDP_MODEL_DESCRIBEAUTHACCOUNTSRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUTHACCOUNTSRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeAuthAccountsResult : public ServiceResult
-			{
-			public:
-				struct Account
-				{
-					std::string authFullName;
-					std::string loginName;
-					std::string fullName;
-					long id;
-					std::string authLoginName;
-					long authTime;
-				};
-
-
-				DescribeAuthAccountsResult();
-				explicit DescribeAuthAccountsResult(const std::string &payload);
-				~DescribeAuthAccountsResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getCurrentPage()const;
-				std::vector<Account> getItems()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				int totalCount_;
-				int pageSize_;
-				int currentPage_;
-				std::vector<Account> items_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUTHACCOUNTSRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeColumnsRequest.h

@@ -39,10 +39,14 @@ namespace AlibabaCloud
 				void setProductCode(const std::string& productCode);
 				std::string getRiskLevels()const;
 				void setRiskLevels(const std::string& riskLevels);
+				std::string getRuleName()const;
+				void setRuleName(const std::string& ruleName);
 				std::string getQueryName()const;
 				void setQueryName(const std::string& queryName);
 				long getRiskLevelId()const;
 				void setRiskLevelId(long riskLevelId);
+				std::string getSensLevelName()const;
+				void setSensLevelName(const std::string& sensLevelName);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
 				int getPageSize()const;
@@ -51,6 +55,8 @@ namespace AlibabaCloud
 				void setTableId(long tableId);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				std::string getTableName()const;
+				void setTableName(const std::string& tableName);
 				int getFeatureType()const;
 				void setFeatureType(int featureType);
 				std::string getOrderBy()const;
@@ -59,6 +65,8 @@ namespace AlibabaCloud
 				void setCurrentPage(int currentPage);
 				long getInstanceId()const;
 				void setInstanceId(long instanceId);
+				std::string getInstanceName()const;
+				void setInstanceName(const std::string& instanceName);
 				std::string getName()const;
 				void setName(const std::string& name);
 				long getRuleId()const;
@@ -67,16 +75,20 @@ namespace AlibabaCloud
             private:
 				std::string productCode_;
 				std::string riskLevels_;
+				std::string ruleName_;
 				std::string queryName_;
 				long riskLevelId_;
+				std::string sensLevelName_;
 				std::string sourceIp_;
 				int pageSize_;
 				long tableId_;
 				std::string lang_;
+				std::string tableName_;
 				int featureType_;
 				std::string orderBy_;
 				int currentPage_;
 				long instanceId_;
+				std::string instanceName_;
 				std::string name_;
 				long ruleId_;
 

sddp/include/alibabacloud/sddp/model/DescribeColumnsResult.h

@@ -42,13 +42,19 @@ namespace AlibabaCloud
 					std::string odpsRiskLevelName;
 					long riskLevelId;
 					std::string departName;
+					long revisionId;
 					std::string name;
+					std::string instanceName;
+					long revisionStatus;
+					std::string tableName;
+					std::string sensLevelName;
 					long creationTime;
-					bool sensitive;
 					std::string dataType;
+					bool sensitive;
 					std::string riskLevelName;
 					std::string id;
 					std::string ruleName;
+					std::vector<std::string> sampleList;
 				};
 
 

sddp/include/alibabacloud/sddp/model/DescribeDataAssetsResult.h

@@ -44,7 +44,7 @@ namespace AlibabaCloud
 					long riskLevelId;
 					std::string departName;
 					std::string name;
-					int labelsec;
+					bool labelsec;
 					int totalCount;
 					long creationTime;
 					bool sensitive;

sddp/include/alibabacloud/sddp/model/DescribeDataHubConnectorsRequest.h

@@ -1,72 +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_SDDP_MODEL_DESCRIBEDATAHUBCONNECTORSREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBCONNECTORSREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDataHubConnectorsRequest : public RpcServiceRequest
-			{
-
-			public:
-				DescribeDataHubConnectorsRequest();
-				~DescribeDataHubConnectorsRequest();
-
-				long getTopicId()const;
-				void setTopicId(long topicId);
-				std::string getSourceIp()const;
-				void setSourceIp(const std::string& sourceIp);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
-				std::string getLang()const;
-				void setLang(const std::string& lang);
-				long getProjectId()const;
-				void setProjectId(long projectId);
-				std::string getKey()const;
-				void setKey(const std::string& key);
-				int getFeatureType()const;
-				void setFeatureType(int featureType);
-				int getCurrentPage()const;
-				void setCurrentPage(int currentPage);
-				long getDepartId()const;
-				void setDepartId(long departId);
-
-            private:
-				long topicId_;
-				std::string sourceIp_;
-				int pageSize_;
-				std::string lang_;
-				long projectId_;
-				std::string key_;
-				int featureType_;
-				int currentPage_;
-				long departId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBCONNECTORSREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeDataHubConnectorsResult.h

@@ -1,71 +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_SDDP_MODEL_DESCRIBEDATAHUBCONNECTORSRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBCONNECTORSRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDataHubConnectorsResult : public ServiceResult
-			{
-			public:
-				struct Connector
-				{
-					std::string connectorPath;
-					std::string loginName;
-					std::string connectorProduct;
-					std::string description;
-					long userId;
-					long creationTime;
-					std::string displayName;
-					std::string riskLevelName;
-					long id;
-					long riskLevelId;
-					std::string name;
-				};
-
-
-				DescribeDataHubConnectorsResult();
-				explicit DescribeDataHubConnectorsResult(const std::string &payload);
-				~DescribeDataHubConnectorsResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getCurrentPage()const;
-				std::vector<Connector> getItems()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				int totalCount_;
-				int pageSize_;
-				int currentPage_;
-				std::vector<Connector> items_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBCONNECTORSRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeDataHubProjectsRequest.h

@@ -1,69 +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_SDDP_MODEL_DESCRIBEDATAHUBPROJECTSREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBPROJECTSREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDataHubProjectsRequest : public RpcServiceRequest
-			{
-
-			public:
-				DescribeDataHubProjectsRequest();
-				~DescribeDataHubProjectsRequest();
-
-				std::string getSourceIp()const;
-				void setSourceIp(const std::string& sourceIp);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
-				std::string getLang()const;
-				void setLang(const std::string& lang);
-				std::string getKey()const;
-				void setKey(const std::string& key);
-				int getQueryType()const;
-				void setQueryType(int queryType);
-				int getFeatureType()const;
-				void setFeatureType(int featureType);
-				int getCurrentPage()const;
-				void setCurrentPage(int currentPage);
-				long getDepartId()const;
-				void setDepartId(long departId);
-
-            private:
-				std::string sourceIp_;
-				int pageSize_;
-				std::string lang_;
-				std::string key_;
-				int queryType_;
-				int featureType_;
-				int currentPage_;
-				long departId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBPROJECTSREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeDataHubSubscriptionsRequest.h

@@ -1,72 +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_SDDP_MODEL_DESCRIBEDATAHUBSUBSCRIPTIONSREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBSUBSCRIPTIONSREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDataHubSubscriptionsRequest : public RpcServiceRequest
-			{
-
-			public:
-				DescribeDataHubSubscriptionsRequest();
-				~DescribeDataHubSubscriptionsRequest();
-
-				long getTopicId()const;
-				void setTopicId(long topicId);
-				std::string getSourceIp()const;
-				void setSourceIp(const std::string& sourceIp);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
-				std::string getLang()const;
-				void setLang(const std::string& lang);
-				long getProjectId()const;
-				void setProjectId(long projectId);
-				std::string getKey()const;
-				void setKey(const std::string& key);
-				int getFeatureType()const;
-				void setFeatureType(int featureType);
-				int getCurrentPage()const;
-				void setCurrentPage(int currentPage);
-				long getDepartId()const;
-				void setDepartId(long departId);
-
-            private:
-				long topicId_;
-				std::string sourceIp_;
-				int pageSize_;
-				std::string lang_;
-				long projectId_;
-				std::string key_;
-				int featureType_;
-				int currentPage_;
-				long departId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBSUBSCRIPTIONSREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeDataHubSubscriptionsResult.h

@@ -1,72 +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_SDDP_MODEL_DESCRIBEDATAHUBSUBSCRIPTIONSRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBSUBSCRIPTIONSRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDataHubSubscriptionsResult : public ServiceResult
-			{
-			public:
-				struct Subscription
-				{
-					std::string loginName;
-					std::string description;
-					std::string applicationName;
-					std::string state;
-					long userId;
-					long creationTime;
-					std::string displayName;
-					std::string subscriptionDisplayName;
-					long id;
-					long subscriptionUserId;
-					std::string subscriptionUserName;
-					std::string name;
-				};
-
-
-				DescribeDataHubSubscriptionsResult();
-				explicit DescribeDataHubSubscriptionsResult(const std::string &payload);
-				~DescribeDataHubSubscriptionsResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getCurrentPage()const;
-				std::vector<Subscription> getItems()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				int totalCount_;
-				int pageSize_;
-				int currentPage_;
-				std::vector<Subscription> items_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBSUBSCRIPTIONSRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeDataHubTopicsRequest.h

@@ -1,69 +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_SDDP_MODEL_DESCRIBEDATAHUBTOPICSREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBTOPICSREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDataHubTopicsRequest : public RpcServiceRequest
-			{
-
-			public:
-				DescribeDataHubTopicsRequest();
-				~DescribeDataHubTopicsRequest();
-
-				std::string getSourceIp()const;
-				void setSourceIp(const std::string& sourceIp);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
-				std::string getLang()const;
-				void setLang(const std::string& lang);
-				long getProjectId()const;
-				void setProjectId(long projectId);
-				std::string getKey()const;
-				void setKey(const std::string& key);
-				int getFeatureType()const;
-				void setFeatureType(int featureType);
-				int getCurrentPage()const;
-				void setCurrentPage(int currentPage);
-				long getDepartId()const;
-				void setDepartId(long departId);
-
-            private:
-				std::string sourceIp_;
-				int pageSize_;
-				std::string lang_;
-				long projectId_;
-				std::string key_;
-				int featureType_;
-				int currentPage_;
-				long departId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBTOPICSREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeDataHubTopicsResult.h

@@ -1,69 +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_SDDP_MODEL_DESCRIBEDATAHUBTOPICSRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBTOPICSRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDataHubTopicsResult : public ServiceResult
-			{
-			public:
-				struct Topic
-				{
-					int lifeCycle;
-					std::string loginName;
-					std::string description;
-					std::string recordType;
-					long userId;
-					long creationTime;
-					std::string displayName;
-					long id;
-					std::string name;
-				};
-
-
-				DescribeDataHubTopicsResult();
-				explicit DescribeDataHubTopicsResult(const std::string &payload);
-				~DescribeDataHubTopicsResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getCurrentPage()const;
-				std::vector<Topic> getItems()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				int totalCount_;
-				int pageSize_;
-				int currentPage_;
-				std::vector<Topic> items_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBTOPICSRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeDataLimitSetRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUTHACCOUNTSREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUTHACCOUNTSREQUEST_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSETREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSETREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,33 +28,30 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeAuthAccountsRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SDDP_EXPORT DescribeDataLimitSetRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeAuthAccountsRequest();
-				~DescribeAuthAccountsRequest();
+				DescribeDataLimitSetRequest();
+				~DescribeDataLimitSetRequest();
 
-				int getFeatureType()const;
-				void setFeatureType(int featureType);
-				int getCurrentPage()const;
-				void setCurrentPage(int currentPage);
+				std::string getParentId()const;
+				void setParentId(const std::string& parentId);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				int getResourceType()const;
+				void setResourceType(int resourceType);
 
             private:
-				int featureType_;
-				int currentPage_;
+				std::string parentId_;
 				std::string sourceIp_;
-				int pageSize_;
 				std::string lang_;
+				int resourceType_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUTHACCOUNTSREQUEST_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSETREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeDataLimitSetResult.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSETRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT DescribeDataLimitSetResult : public ServiceResult
+			{
+			public:
+				struct DataLimitSet
+				{
+					struct DataLimit
+					{
+						std::string parentId;
+						std::string connector;
+						std::string userName;
+						bool supportEvent;
+						int logStoreDay;
+						int port;
+						int checkStatus;
+						int eventStatus;
+						long resourceType;
+						std::string localName;
+						long gmtCreate;
+						int auditStatus;
+						std::string resourceTypeCode;
+						std::string regionId;
+						long id;
+						std::string checkStatusName;
+					};
+					struct OssBucket
+					{
+						std::string bucketName;
+						std::string regionId;
+					};
+					struct Region
+					{
+						std::string regionId;
+						std::string localName;
+					};
+					int totalCount;
+					std::vector<DataLimit> dataLimitList;
+					std::string resourceTypeCode;
+					std::vector<OssBucket> ossBucketList;
+					long resourceType;
+					std::vector<Region> regionList;
+				};
+
+
+				DescribeDataLimitSetResult();
+				explicit DescribeDataLimitSetResult(const std::string &payload);
+				~DescribeDataLimitSetResult();
+				DataLimitSet getDataLimitSet()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				DataLimitSet dataLimitSet_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSETRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeDataLimitsInstanceDimRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_VALIDATECONNECTORREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_VALIDATECONNECTORREQUEST_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSINSTANCEDIMREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSINSTANCEDIMREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,42 +28,60 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT ValidateConnectorRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SDDP_EXPORT DescribeDataLimitsInstanceDimRequest : public RpcServiceRequest
 			{
 
 			public:
-				ValidateConnectorRequest();
-				~ValidateConnectorRequest();
+				DescribeDataLimitsInstanceDimRequest();
+				~DescribeDataLimitsInstanceDimRequest();
 
+				long getStartTime()const;
+				void setStartTime(long startTime);
 				std::string getParentId()const;
 				void setParentId(const std::string& parentId);
-				std::string getPassword()const;
-				void setPassword(const std::string& password);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
+				int getEnable()const;
+				void setEnable(int enable);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getCheckStatus()const;
+				void setCheckStatus(int checkStatus);
+				int getDatamaskStatus()const;
+				void setDatamaskStatus(int datamaskStatus);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
 				std::string getServiceRegionId()const;
 				void setServiceRegionId(const std::string& serviceRegionId);
+				std::string getEngineType()const;
+				void setEngineType(const std::string& engineType);
+				int getAuditStatus()const;
+				void setAuditStatus(int auditStatus);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				int getCurrentPage()const;
+				void setCurrentPage(int currentPage);
 				int getResourceType()const;
 				void setResourceType(int resourceType);
-				std::string getConnector()const;
-				void setConnector(const std::string& connector);
-				std::string getUserName()const;
-				void setUserName(const std::string& userName);
 
             private:
+				long startTime_;
 				std::string parentId_;
-				std::string password_;
 				std::string sourceIp_;
+				int enable_;
+				int pageSize_;
+				int checkStatus_;
+				int datamaskStatus_;
 				std::string lang_;
 				std::string serviceRegionId_;
+				std::string engineType_;
+				int auditStatus_;
+				long endTime_;
+				int currentPage_;
 				int resourceType_;
-				std::string connector_;
-				std::string userName_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_VALIDATECONNECTORREQUEST_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSINSTANCEDIMREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeDataLimitsInstanceDimResult.h

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SDDP_MODEL_DESCRIBEDATALIMITSINSTANCEDIMRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSINSTANCEDIMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT DescribeDataLimitsInstanceDimResult : public ServiceResult
+			{
+			public:
+				struct DataLimit
+				{
+					struct DataLimitListInner
+					{
+						int agentState;
+						std::string connector;
+						int samplingSize;
+						int processStatus;
+						int logStoreDay;
+						int port;
+						int checkStatus;
+						int eventStatus;
+						bool supportDatamask;
+						std::string dbVersion;
+						bool supportOcr;
+						long lastFinishedTime;
+						int enable;
+						std::string engineType;
+						std::string agentId;
+						bool supportScan;
+						std::string parentId;
+						std::string userName;
+						bool supportAgentInstall;
+						bool supportEvent;
+						long resourceType;
+						std::string localName;
+						long gmtCreate;
+						int totalCount;
+						int auditStatus;
+						int datamaskStatus;
+						int autoScan;
+						std::string resourceTypeCode;
+						long nextStartTime;
+						bool supportAudit;
+						std::string regionId;
+						long id;
+						std::string errorCode;
+						int ocrStatus;
+						std::string checkStatusName;
+						std::string errorMessage;
+						int processTotalCount;
+						bool autoCreateAccount;
+					};
+					int agentState;
+					std::string connector;
+					int samplingSize;
+					int processStatus;
+					int logStoreDay;
+					int port;
+					int checkStatus;
+					bool supportDatamask;
+					std::string dbVersion;
+					bool supportOcr;
+					long lastFinishedTime;
+					int enable;
+					std::string engineType;
+					std::string agentId;
+					bool supportScan;
+					std::string parentId;
+					std::string userName;
+					bool supportAgentInstall;
+					long resourceType;
+					std::string localName;
+					long gmtCreate;
+					int totalCount;
+					int auditStatus;
+					int datamaskStatus;
+					std::vector<DataLimit::DataLimitListInner> dataLimitList;
+					int autoScan;
+					std::string resourceTypeCode;
+					long nextStartTime;
+					bool supportAudit;
+					std::string instanceDescription;
+					std::string regionId;
+					long id;
+					std::string errorCode;
+					int ocrStatus;
+					std::string checkStatusName;
+					std::string errorMessage;
+					int processTotalCount;
+				};
+
+
+				DescribeDataLimitsInstanceDimResult();
+				explicit DescribeDataLimitsInstanceDimResult(const std::string &payload);
+				~DescribeDataLimitsInstanceDimResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getCurrentPage()const;
+				std::vector<DataLimit> getItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int currentPage_;
+				std::vector<DataLimit> items_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATALIMITSINSTANCEDIMRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeDataLimitsRequest.h

@@ -35,16 +35,20 @@ namespace AlibabaCloud
 				DescribeDataLimitsRequest();
 				~DescribeDataLimitsRequest();
 
+				long getStartTime()const;
+				void setStartTime(long startTime);
 				std::string getParentId()const;
 				void setParentId(const std::string& parentId);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
-				std::string getRegionId()const;
-				void setRegionId(const std::string& regionId);
+				int getEnable()const;
+				void setEnable(int enable);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
 				int getCheckStatus()const;
 				void setCheckStatus(int checkStatus);
+				int getDatamaskStatus()const;
+				void setDatamaskStatus(int datamaskStatus);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
 				std::string getServiceRegionId()const;
@@ -53,21 +57,26 @@ namespace AlibabaCloud
 				void setEngineType(const std::string& engineType);
 				int getAuditStatus()const;
 				void setAuditStatus(int auditStatus);
+				long getEndTime()const;
+				void setEndTime(long endTime);
 				int getCurrentPage()const;
 				void setCurrentPage(int currentPage);
 				int getResourceType()const;
 				void setResourceType(int resourceType);
 
             private:
+				long startTime_;
 				std::string parentId_;
 				std::string sourceIp_;
-				std::string regionId_;
+				int enable_;
 				int pageSize_;
 				int checkStatus_;
+				int datamaskStatus_;
 				std::string lang_;
 				std::string serviceRegionId_;
 				std::string engineType_;
 				int auditStatus_;
+				long endTime_;
 				int currentPage_;
 				int resourceType_;
 

sddp/include/alibabacloud/sddp/model/DescribeDataLimitsResult.h

@@ -34,26 +34,43 @@ namespace AlibabaCloud
 			public:
 				struct DataLimit
 				{
-					std::string parentId;
+					int agentState;
 					std::string connector;
-					std::string userName;
+					int samplingSize;
 					int processStatus;
 					int logStoreDay;
 					int port;
 					int checkStatus;
+					int eventStatus;
+					bool supportDatamask;
+					std::string dbVersion;
+					bool supportOcr;
+					long lastFinishedTime;
+					int enable;
+					std::string engineType;
+					std::string agentId;
+					bool supportScan;
+					std::string parentId;
+					std::string userName;
+					bool supportAgentInstall;
+					bool supportEvent;
+					std::string instanceId;
+					std::string tenantName;
 					long resourceType;
 					std::string localName;
 					long gmtCreate;
 					int totalCount;
 					int auditStatus;
-					long lastFinishedTime;
+					int datamaskStatus;
 					int autoScan;
 					std::string resourceTypeCode;
-					int enable;
-					std::string engineType;
+					long nextStartTime;
+					bool supportAudit;
+					std::string instanceDescription;
 					std::string regionId;
 					long id;
 					std::string errorCode;
+					int ocrStatus;
 					std::string checkStatusName;
 					std::string errorMessage;
 					int processTotalCount;

sddp/include/alibabacloud/sddp/model/DescribeDataMaskingRunHistoryRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				int getSrcType()const;
 				void setSrcType(int srcType);
+				long getMainProcessId()const;
+				void setMainProcessId(long mainProcessId);
 				long getStartTime()const;
 				void setStartTime(long startTime);
 				std::string getSourceIp()const;
@@ -47,6 +49,8 @@ namespace AlibabaCloud
 				void setLang(const std::string& lang);
 				std::string getTaskId()const;
 				void setTaskId(const std::string& taskId);
+				std::string getSrcTableName()const;
+				void setSrcTableName(const std::string& srcTableName);
 				int getFeatureType()const;
 				void setFeatureType(int featureType);
 				long getEndTime()const;
@@ -60,11 +64,13 @@ namespace AlibabaCloud
 
             private:
 				int srcType_;
+				long mainProcessId_;
 				long startTime_;
 				std::string sourceIp_;
 				int pageSize_;
 				std::string lang_;
 				std::string taskId_;
+				std::string srcTableName_;
 				int featureType_;
 				long endTime_;
 				int currentPage_;

sddp/include/alibabacloud/sddp/model/DescribeDataMaskingRunHistoryResult.h

@@ -37,16 +37,21 @@ namespace AlibabaCloud
 					int status;
 					int runIndex;
 					std::string taskId;
+					long endTime;
 					int percentage;
+					int hasDownloadFile;
 					long maskingCount;
 					std::string failCode;
 					long startTime;
+					std::string srcTableName;
 					std::string dstTypeCode;
 					long conflictCount;
 					int dstType;
 					int type;
 					int srcType;
+					std::string failMsg;
 					long id;
+					int hasSubProcess;
 					std::string srcTypeCode;
 				};
 

sddp/include/alibabacloud/sddp/model/DescribeDataMaskingTasksResult.h

@@ -43,6 +43,7 @@ namespace AlibabaCloud
 					std::string dstTypeCode;
 					std::string srcPath;
 					int dstType;
+					bool originalTable;
 					long gmtCreate;
 					std::string taskName;
 					int srcType;

sddp/include/alibabacloud/sddp/model/DescribeDataTotalCountRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEDEPARTSREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDEPARTSREQUEST_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATATOTALCOUNTREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATATOTALCOUNTREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,39 +28,36 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDepartsRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SDDP_EXPORT DescribeDataTotalCountRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeDepartsRequest();
-				~DescribeDepartsRequest();
+				DescribeDataTotalCountRequest();
+				~DescribeDataTotalCountRequest();
 
-				int getAccountType()const;
-				void setAccountType(int accountType);
-				std::string getSourceIp()const;
-				void setSourceIp(const std::string& sourceIp);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
-				std::string getLang()const;
-				void setLang(const std::string& lang);
-				std::string getKey()const;
-				void setKey(const std::string& key);
+				std::string getProductCode()const;
+				void setProductCode(const std::string& productCode);
 				int getFeatureType()const;
 				void setFeatureType(int featureType);
-				int getCurrentPage()const;
-				void setCurrentPage(int currentPage);
+				int getCountType()const;
+				void setCountType(int countType);
+				long getInstanceId()const;
+				void setInstanceId(long instanceId);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
 
             private:
-				int accountType_;
-				std::string sourceIp_;
-				int pageSize_;
-				std::string lang_;
-				std::string key_;
+				std::string productCode_;
 				int featureType_;
-				int currentPage_;
+				int countType_;
+				long instanceId_;
+				std::string sourceIp_;
+				std::string lang_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDEPARTSREQUEST_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATATOTALCOUNTREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeDataTotalCountResult.h

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SDDP_MODEL_DESCRIBEDATATOTALCOUNTRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATATOTALCOUNTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT DescribeDataTotalCountResult : public ServiceResult
+			{
+			public:
+				struct DataCount
+				{
+					struct Instance
+					{
+						struct RiskCount
+						{
+							long id;
+							long count;
+							std::string name;
+						};
+						long totalCount;
+						long count;
+						long lastSensitiveCount;
+						long sensitiveCount;
+						std::vector<RiskCount> riskCountList;
+						long lastCount;
+					};
+					struct Table
+					{
+						struct RiskCount2
+						{
+							long id;
+							long count;
+							std::string name;
+						};
+						long totalCount;
+						std::vector<RiskCount2> riskCountList1;
+						long count;
+						long lastSensitiveCount;
+						long sensitiveCount;
+						long lastCount;
+					};
+					struct Package
+					{
+						struct RiskCount4
+						{
+							long id;
+							long count;
+							std::string name;
+						};
+						long totalCount;
+						long count;
+						long lastSensitiveCount;
+						long sensitiveCount;
+						std::vector<RiskCount4> riskCountList3;
+						long lastCount;
+					};
+					struct Column
+					{
+						struct RiskCount6
+						{
+							long id;
+							long count;
+							std::string name;
+						};
+						struct ColumnCount
+						{
+							long id;
+							long count;
+							std::string name;
+						};
+						long totalCount;
+						std::vector<ColumnCount> columnRuleTop;
+						long count;
+						long lastSensitiveCount;
+						long sensitiveCount;
+						std::vector<RiskCount6> riskCountList5;
+						long lastCount;
+					};
+					struct Oss
+					{
+						struct RiskCount8
+						{
+							long id;
+							long count;
+							std::string name;
+						};
+						struct OssCount
+						{
+							long id;
+							long count;
+							std::string name;
+						};
+						long totalCount;
+						std::vector<RiskCount8> riskCountList7;
+						long count;
+						long lastSensitiveCount;
+						std::vector<OssCount> ossRuleTop;
+						long sensitiveCount;
+						long lastCount;
+					};
+					Table table;
+					Instance instance;
+					Column column;
+					Package package;
+					Oss oss;
+				};
+
+
+				DescribeDataTotalCountResult();
+				explicit DescribeDataTotalCountResult(const std::string &payload);
+				~DescribeDataTotalCountResult();
+				DataCount getDataCount()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				DataCount dataCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATATOTALCOUNTRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeDepartsResult.h

@@ -1,67 +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_SDDP_MODEL_DESCRIBEDEPARTSRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDEPARTSRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDepartsResult : public ServiceResult
-			{
-			public:
-				struct Depart
-				{
-					std::string comment;
-					long parentDepartId;
-					int level;
-					long id;
-					std::string parentDepartName;
-					std::string departName;
-					long departId;
-				};
-
-
-				DescribeDepartsResult();
-				explicit DescribeDepartsResult(const std::string &payload);
-				~DescribeDepartsResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getCurrentPage()const;
-				std::vector<Depart> getItems()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				int totalCount_;
-				int pageSize_;
-				int currentPage_;
-				std::vector<Depart> items_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDEPARTSRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeEventDetailResult.h

@@ -63,11 +63,28 @@ namespace AlibabaCloud
 						std::vector<ContentItem> content;
 						std::vector<ChartItem> chart;
 					};
-					int status;
+					struct HandleInfo
+					{
+						int status;
+						long disableTime;
+						std::string handlerType;
+						int handlerValue;
+						std::string currentValue;
+						long enableTime;
+						long id;
+						std::string handlerName;
+					};
 					std::string loginName;
 					std::string typeName;
 					std::string dataInstance;
 					bool backed;
+					std::string userIdValue;
+					std::vector<HandleInfo> handleInfoList;
+					std::string dealLoginName;
+					std::string subTypeName;
+					std::string dealUserIdValue;
+					std::string displayName;
+					int status;
 					std::string productCode;
 					std::string typeCode;
 					std::string statusName;
@@ -75,13 +92,11 @@ namespace AlibabaCloud
 					long alertTime;
 					std::string departName;
 					std::string dealReason;
-					std::string dealLoginName;
+					std::string logDetail;
 					std::string dealDisplayName;
-					std::string subTypeName;
 					long userId;
 					long eventTime;
 					long dealUserId;
-					std::string displayName;
 					long id;
 					long dealTime;
 					Detail detail;

sddp/include/alibabacloud/sddp/model/DescribeEventTopRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEORIGINALLOGSREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEORIGINALLOGSREQUEST_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTOPREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTOPREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,66 +28,69 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeOriginalLogsRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SDDP_EXPORT DescribeEventTopRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeOriginalLogsRequest();
-				~DescribeOriginalLogsRequest();
+				DescribeEventTopRequest();
+				~DescribeEventTopRequest();
 
-				long getStartTime()const;
-				void setStartTime(long startTime);
-				std::string getLogType()const;
-				void setLogType(const std::string& logType);
+				std::string getProductCode()const;
+				void setProductCode(const std::string& productCode);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				long getUserId()const;
+				void setUserId(long userId);
+				std::string getTypeCode()const;
+				void setTypeCode(const std::string& typeCode);
+				std::string getSubTypeCode()const;
+				void setSubTypeCode(const std::string& subTypeCode);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
-				std::string getClientIp()const;
-				void setClientIp(const std::string& clientIp);
+				std::string getTargetProductCode()const;
+				void setTargetProductCode(const std::string& targetProductCode);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
-				std::string getTableName()const;
-				void setTableName(const std::string& tableName);
-				std::string getOssObjectKey()const;
-				void setOssObjectKey(const std::string& ossObjectKey);
+				std::string getDealUserId()const;
+				void setDealUserId(const std::string& dealUserId);
 				int getFeatureType()const;
 				void setFeatureType(int featureType);
-				long getEndTime()const;
-				void setEndTime(long endTime);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
 				int getCurrentPage()const;
 				void setCurrentPage(int currentPage);
-				std::string getClientUa()const;
-				void setClientUa(const std::string& clientUa);
 				std::string getInstanceName()const;
 				void setInstanceName(const std::string& instanceName);
-				std::string getDatabaseName()const;
-				void setDatabaseName(const std::string& databaseName);
-				std::string getOperateType()const;
-				void setOperateType(const std::string& operateType);
+				long getDepartId()const;
+				void setDepartId(long departId);
+				std::string getStatus()const;
+				void setStatus(const std::string& status);
 				std::string getUserName()const;
 				void setUserName(const std::string& userName);
 
             private:
-				long startTime_;
-				std::string logType_;
+				std::string productCode_;
+				std::string startTime_;
+				long userId_;
+				std::string typeCode_;
+				std::string subTypeCode_;
 				std::string sourceIp_;
-				std::string clientIp_;
+				std::string targetProductCode_;
 				int pageSize_;
 				std::string lang_;
-				std::string tableName_;
-				std::string ossObjectKey_;
+				std::string dealUserId_;
 				int featureType_;
-				long endTime_;
+				std::string endTime_;
 				int currentPage_;
-				std::string clientUa_;
 				std::string instanceName_;
-				std::string databaseName_;
-				std::string operateType_;
+				long departId_;
+				std::string status_;
 				std::string userName_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEORIGINALLOGSREQUEST_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTOPREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeEventTopResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDINSTANCESRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDINSTANCESRESULT_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTOPRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTOPRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,29 +29,32 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeCloudInstancesResult : public ServiceResult
+			class ALIBABACLOUD_SDDP_EXPORT DescribeEventTopResult : public ServiceResult
 			{
 			public:
-				struct CloudInstance
+				struct DataCount
 				{
-					std::string instanceId;
-					std::string engine;
-					std::string name;
+					std::string instanceName;
+					std::string userName;
+					std::string productCode;
+					std::string remoteIp;
+					std::string eventName;
+					long id;
 				};
 
 
-				DescribeCloudInstancesResult();
-				explicit DescribeCloudInstancesResult(const std::string &payload);
-				~DescribeCloudInstancesResult();
-				std::vector<CloudInstance> getCloudInstanceList()const;
+				DescribeEventTopResult();
+				explicit DescribeEventTopResult(const std::string &payload);
+				~DescribeEventTopResult();
+				std::vector<DataCount> getDataCountList()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<CloudInstance> cloudInstanceList_;
+				std::vector<DataCount> dataCountList_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDINSTANCESRESULT_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTOPRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeEventTypesDetailRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_MODIFYSALEFLOWCOUNTTYPEREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_MODIFYSALEFLOWCOUNTTYPEREQUEST_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTYPESDETAILREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTYPESDETAILREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,22 +28,22 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT ModifySaleFlowCountTypeRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SDDP_EXPORT DescribeEventTypesDetailRequest : public RpcServiceRequest
 			{
 
 			public:
-				ModifySaleFlowCountTypeRequest();
-				~ModifySaleFlowCountTypeRequest();
+				DescribeEventTypesDetailRequest();
+				~DescribeEventTypesDetailRequest();
 
-				int getSaleFlowCountType()const;
-				void setSaleFlowCountType(int saleFlowCountType);
+				std::string getCode()const;
+				void setCode(const std::string& code);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
 
             private:
-				int saleFlowCountType_;
+				std::string code_;
 				std::string sourceIp_;
 				std::string lang_;
 
@@ -51,4 +51,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_MODIFYSALEFLOWCOUNTTYPEREQUEST_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTYPESDETAILREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeEventTypesDetailResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBPROJECTSRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBPROJECTSRESULT_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTYPESDETAILRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTYPESDETAILRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,42 +29,45 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeDataHubProjectsResult : public ServiceResult
+			class ALIBABACLOUD_SDDP_EXPORT DescribeEventTypesDetailResult : public ServiceResult
 			{
 			public:
-				struct Project
+				struct UserStatus
 				{
-					std::string loginName;
+					int status;
+					int eventHitCount;
+					std::string configValue;
 					std::string description;
-					long userId;
-					long creationTime;
-					std::string displayName;
-					std::string topicTupleCount;
-					long id;
-					std::string topicCount;
-					long topicBlobCount;
+					std::string riskEvent;
+					std::string descModel;
+					std::string configDescription;
+					std::string dealSuggestion;
+					std::string parentTypeName;
+					std::string code;
+					std::string descEvent;
+					std::string riskName;
 					std::string name;
+					std::string adaptedProduct;
+					std::string configCode;
+					long parentTypeId;
+					int configContentType;
+					int riskLevel;
+					int accessCount;
 				};
 
 
-				DescribeDataHubProjectsResult();
-				explicit DescribeDataHubProjectsResult(const std::string &payload);
-				~DescribeDataHubProjectsResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getCurrentPage()const;
-				std::vector<Project> getItems()const;
+				DescribeEventTypesDetailResult();
+				explicit DescribeEventTypesDetailResult(const std::string &payload);
+				~DescribeEventTypesDetailResult();
+				UserStatus getUserStatus()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int totalCount_;
-				int pageSize_;
-				int currentPage_;
-				std::vector<Project> items_;
+				UserStatus userStatus_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEDATAHUBPROJECTSRESULT_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEEVENTTYPESDETAILRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeEventTypesRequest.h

@@ -35,17 +35,23 @@ namespace AlibabaCloud
 				DescribeEventTypesRequest();
 				~DescribeEventTypesRequest();
 
+				int getResourceId()const;
+				void setResourceId(int resourceId);
 				long getParentTypeId()const;
 				void setParentTypeId(long parentTypeId);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				int getStatus()const;
+				void setStatus(int status);
 
             private:
+				int resourceId_;
 				long parentTypeId_;
 				std::string sourceIp_;
 				std::string lang_;
+				int status_;
 
 			};
 		}

sddp/include/alibabacloud/sddp/model/DescribeEventTypesResult.h

@@ -37,7 +37,13 @@ namespace AlibabaCloud
 					struct SubType
 					{
 						int status;
+						int eventHitCount;
+						std::string adaptedProduct;
+						std::string configValue;
 						std::string description;
+						std::string configCode;
+						int configContentType;
+						std::string configDescription;
 						long id;
 						std::string code;
 						std::string name;

sddp/include/alibabacloud/sddp/model/DescribeEventsRequest.h

@@ -51,6 +51,8 @@ namespace AlibabaCloud
 				void setTargetProductCode(const std::string& targetProductCode);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
+				long getId()const;
+				void setId(long id);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
 				std::string getDealUserId()const;
@@ -61,10 +63,14 @@ namespace AlibabaCloud
 				void setEndTime(const std::string& endTime);
 				int getCurrentPage()const;
 				void setCurrentPage(int currentPage);
+				std::string getInstanceName()const;
+				void setInstanceName(const std::string& instanceName);
 				long getDepartId()const;
 				void setDepartId(long departId);
 				std::string getStatus()const;
 				void setStatus(const std::string& status);
+				std::string getUserName()const;
+				void setUserName(const std::string& userName);
 
             private:
 				std::string productCode_;
@@ -75,13 +81,16 @@ namespace AlibabaCloud
 				std::string sourceIp_;
 				std::string targetProductCode_;
 				int pageSize_;
+				long id_;
 				std::string lang_;
 				std::string dealUserId_;
 				int featureType_;
 				std::string endTime_;
 				int currentPage_;
+				std::string instanceName_;
 				long departId_;
 				std::string status_;
+				std::string userName_;
 
 			};
 		}

sddp/include/alibabacloud/sddp/model/DescribeEventsResult.h

@@ -38,12 +38,15 @@ namespace AlibabaCloud
 					std::string loginName;
 					std::string typeName;
 					bool backed;
+					std::string userIdValue;
 					std::string productCode;
 					std::string typeCode;
 					std::string statusName;
 					std::string subTypeCode;
 					long alertTime;
 					std::string departName;
+					std::string instanceName;
+					int warnLevel;
 					std::string dealLoginName;
 					std::string dealDisplayName;
 					std::string subTypeName;
@@ -51,6 +54,7 @@ namespace AlibabaCloud
 					std::string targetProductCode;
 					long eventTime;
 					long dealUserId;
+					std::string dealUserIdValue;
 					std::string displayName;
 					long id;
 					long dealTime;

sddp/include/alibabacloud/sddp/model/DescribeInstancePortraitRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SDDP_MODEL_DESCRIBEINSTANCEPORTRAITREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEINSTANCEPORTRAITREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT DescribeInstancePortraitRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeInstancePortraitRequest();
+				~DescribeInstancePortraitRequest();
+
+				long getProductId()const;
+				void setProductId(long productId);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+				long getInstanceId()const;
+				void setInstanceId(long instanceId);
+				std::string getItemKeys()const;
+				void setItemKeys(const std::string& itemKeys);
+
+            private:
+				long productId_;
+				std::string sourceIp_;
+				long instanceId_;
+				std::string itemKeys_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEINSTANCEPORTRAITREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeInstancePortraitResult.h

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

sddp/include/alibabacloud/sddp/model/DescribeInstanceSourcesRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDDATABASESREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDDATABASESREQUEST_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEINSTANCESOURCESREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEINSTANCESOURCESREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,33 +28,48 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeCloudDatabasesRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SDDP_EXPORT DescribeInstanceSourcesRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeCloudDatabasesRequest();
-				~DescribeCloudDatabasesRequest();
+				DescribeInstanceSourcesRequest();
+				~DescribeInstanceSourcesRequest();
 
-				long getResourceType()const;
-				void setResourceType(long resourceType);
-				std::string getInstanceId()const;
-				void setInstanceId(const std::string& instanceId);
+				long getProductId()const;
+				void setProductId(long productId);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
 				std::string getServiceRegionId()const;
 				void setServiceRegionId(const std::string& serviceRegionId);
+				std::string getEngineType()const;
+				void setEngineType(const std::string& engineType);
+				int getCurrentPage()const;
+				void setCurrentPage(int currentPage);
+				bool getAuthed()const;
+				void setAuthed(bool authed);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
 
             private:
-				long resourceType_;
-				std::string instanceId_;
+				long productId_;
 				std::string sourceIp_;
+				int pageSize_;
 				std::string lang_;
 				std::string serviceRegionId_;
+				std::string engineType_;
+				int currentPage_;
+				bool authed_;
+				std::string instanceId_;
+				std::string dbName_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDDATABASESREQUEST_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEINSTANCESOURCESREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeInstanceSourcesResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUDITLOGSRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUDITLOGSRESULT_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEINSTANCESOURCESRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEINSTANCESOURCESRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,44 +29,44 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeAuditLogsResult : public ServiceResult
+			class ALIBABACLOUD_SDDP_EXPORT DescribeInstanceSourcesResult : public ServiceResult
 			{
 			public:
-				struct Log
+				struct InstanceSource
 				{
 					std::string userName;
-					std::string productCode;
-					std::string packageName;
-					std::string ossObjectKey;
-					long executeTime;
-					long logTime;
-					std::string ruleId;
-					std::string clientUa;
-					std::string databaseName;
-					std::string clientPort;
-					int executeStatus;
+					long instanceSize;
+					std::string instanceId;
+					int logStoreDay;
+					std::string tenantName;
 					long productId;
-					std::string clientIp;
-					long effectRow;
-					std::string instanceName;
-					std::string tableName;
-					std::string columnName;
-					std::string warnLevel;
-					std::string userId;
-					long creationTime;
+					bool canModifyUserName;
+					long lastModifyTime;
+					std::string instanceDescription1;
+					long gmtCreate;
+					std::string tenantId;
+					long dataLimitId;
+					int auditStatus;
+					std::string lastModifyUserId;
+					std::string regionName;
+					int autoScan;
+					int passwordStatus;
+					int enable;
+					std::string dbName;
+					std::string engineType;
+					std::string instanceDescription;
+					std::string regionId;
 					long id;
-					std::string operateType;
-					std::string ruleName;
 				};
 
 
-				DescribeAuditLogsResult();
-				explicit DescribeAuditLogsResult(const std::string &payload);
-				~DescribeAuditLogsResult();
+				DescribeInstanceSourcesResult();
+				explicit DescribeInstanceSourcesResult(const std::string &payload);
+				~DescribeInstanceSourcesResult();
 				int getTotalCount()const;
 				int getPageSize()const;
 				int getCurrentPage()const;
-				std::vector<Log> getItems()const;
+				std::vector<InstanceSource> getItems()const;
 
 			protected:
 				void parse(const std::string &payload);
@@ -74,10 +74,10 @@ namespace AlibabaCloud
 				int totalCount_;
 				int pageSize_;
 				int currentPage_;
-				std::vector<Log> items_;
+				std::vector<InstanceSource> items_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEAUDITLOGSRESULT_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEINSTANCESOURCESRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeInstancesRequest.h

@@ -45,26 +45,48 @@ namespace AlibabaCloud
 				void setQueryName(const std::string& queryName);
 				long getRiskLevelId()const;
 				void setRiskLevelId(long riskLevelId);
+				std::string getSource()const;
+				void setSource(const std::string& source);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				long getUserId()const;
+				void setUserId(long userId);
+				std::string getNameAccurate()const;
+				void setNameAccurate(const std::string& nameAccurate);
+				std::string getSensLevelName()const;
+				void setSensLevelName(const std::string& sensLevelName);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
+				long getLastFinishTimeStart()const;
+				void setLastFinishTimeStart(long lastFinishTimeStart);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
+				int getCheckStatus()const;
+				void setCheckStatus(int checkStatus);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
 				int getQueryType()const;
 				void setQueryType(int queryType);
 				std::string getServiceRegionId()const;
 				void setServiceRegionId(const std::string& serviceRegionId);
+				std::string getEngineType()const;
+				void setEngineType(const std::string& engineType);
 				int getFeatureType()const;
 				void setFeatureType(int featureType);
 				std::string getOrderBy()const;
 				void setOrderBy(const std::string& orderBy);
+				int getUserType()const;
+				void setUserType(int userType);
+				long getEndTime()const;
+				void setEndTime(long endTime);
 				int getCurrentPage()const;
 				void setCurrentPage(int currentPage);
 				std::string getName()const;
 				void setName(const std::string& name);
 				long getRuleId()const;
 				void setRuleId(long ruleId);
+				long getLastFinishTimeEnd()const;
+				void setLastFinishTimeEnd(long lastFinishTimeEnd);
 
             private:
 				std::string productCode_;
@@ -72,16 +94,27 @@ namespace AlibabaCloud
 				std::string riskLevels_;
 				std::string queryName_;
 				long riskLevelId_;
+				std::string source_;
+				long startTime_;
+				long userId_;
+				std::string nameAccurate_;
+				std::string sensLevelName_;
 				std::string sourceIp_;
+				long lastFinishTimeStart_;
 				int pageSize_;
+				int checkStatus_;
 				std::string lang_;
 				int queryType_;
 				std::string serviceRegionId_;
+				std::string engineType_;
 				int featureType_;
 				std::string orderBy_;
+				int userType_;
+				long endTime_;
 				int currentPage_;
 				std::string name_;
 				long ruleId_;
+				long lastFinishTimeEnd_;
 
 			};
 		}

sddp/include/alibabacloud/sddp/model/DescribeInstancesResult.h

@@ -35,27 +35,34 @@ namespace AlibabaCloud
 				struct Instance
 				{
 					std::string owner;
-					std::string productCode;
 					std::string odpsRiskLevelName;
 					std::string productId;
-					std::string acl;
 					int s2Count;
 					long riskLevelId;
-					std::string departName;
 					std::string name;
+					std::string regionName;
+					int s1Count;
+					bool sensitive;
+					std::string engineType;
+					bool protection;
+					std::string ruleName;
+					std::string productCode;
+					std::string tenantName;
+					std::string countDetails;
+					float riskScore;
+					std::string acl;
+					std::string departName;
+					float lastRiskScore;
 					bool labelsec;
 					int totalCount;
-					std::string regionName;
+					std::string sensLevelName;
 					long lastFinishTime;
 					long creationTime;
-					bool sensitive;
 					std::string riskLevelName;
-					std::string engineType;
+					std::string instanceDescription;
 					long id;
 					std::string regionId;
 					int sensitiveCount;
-					bool protection;
-					std::string ruleName;
 					int s3Count;
 				};
 

sddp/include/alibabacloud/sddp/model/DescribeOssObjectDetailRequest.h

@@ -35,20 +35,20 @@ namespace AlibabaCloud
 				DescribeOssObjectDetailRequest();
 				~DescribeOssObjectDetailRequest();
 
-				int getFeatureType()const;
-				void setFeatureType(int featureType);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
 				long getId()const;
 				void setId(long id);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				int getFeatureType()const;
+				void setFeatureType(int featureType);
 
             private:
-				int featureType_;
 				std::string sourceIp_;
 				long id_;
 				std::string lang_;
+				int featureType_;
 
 			};
 		}

sddp/include/alibabacloud/sddp/model/DescribeOssObjectDetailResult.h

@@ -37,8 +37,12 @@ namespace AlibabaCloud
 					struct Rule
 					{
 						int category;
+						std::string categoryName;
+						std::string riskLevelName;
 						long count;
+						long riskLevelId;
 						std::string ruleName;
+						std::vector<std::string> sampleList;
 					};
 					std::vector<Rule> ruleList;
 					std::string bucketName;

sddp/include/alibabacloud/sddp/model/DescribeOssObjectsRequest.h

@@ -37,22 +37,32 @@ namespace AlibabaCloud
 
 				std::string getRiskLevels()const;
 				void setRiskLevels(const std::string& riskLevels);
+				bool getNeedRiskCount()const;
+				void setNeedRiskCount(bool needRiskCount);
 				std::string getQueryName()const;
 				void setQueryName(const std::string& queryName);
 				int getRiskLevelId()const;
 				void setRiskLevelId(int riskLevelId);
+				long getLastScanTimeEnd()const;
+				void setLastScanTimeEnd(long lastScanTimeEnd);
+				long getLastScanTimeStart()const;
+				void setLastScanTimeStart(long lastScanTimeStart);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				std::string getServiceRegionId()const;
+				void setServiceRegionId(const std::string& serviceRegionId);
 				int getFeatureType()const;
 				void setFeatureType(int featureType);
 				std::string getOrderBy()const;
 				void setOrderBy(const std::string& orderBy);
 				int getCurrentPage()const;
 				void setCurrentPage(int currentPage);
+				std::string getRuleIds()const;
+				void setRuleIds(const std::string& ruleIds);
 				std::string getInstanceId()const;
 				void setInstanceId(const std::string& instanceId);
 				std::string getName()const;
@@ -64,14 +74,19 @@ namespace AlibabaCloud
 
             private:
 				std::string riskLevels_;
+				bool needRiskCount_;
 				std::string queryName_;
 				int riskLevelId_;
+				long lastScanTimeEnd_;
+				long lastScanTimeStart_;
 				std::string sourceIp_;
 				int pageSize_;
 				std::string lang_;
+				std::string serviceRegionId_;
 				int featureType_;
 				std::string orderBy_;
 				int currentPage_;
+				std::string ruleIds_;
 				std::string instanceId_;
 				std::string name_;
 				long ruleId_;

sddp/include/alibabacloud/sddp/model/DescribeOssObjectsResult.h

@@ -34,13 +34,22 @@ namespace AlibabaCloud
 			public:
 				struct Column
 				{
+					struct Rule
+					{
+						long count;
+						long riskLevelId;
+						std::string name;
+					};
 					int ruleCount;
+					std::vector<Column::Rule> ruleList;
 					long category;
 					long instanceId;
 					long size;
+					long lastScanTime;
 					long riskLevelId;
 					std::string name;
 					std::string bucketName;
+					std::string regionName;
 					std::string categoryName;
 					std::string fileId;
 					std::string riskLevelName;

sddp/include/alibabacloud/sddp/model/DescribePrivilegesRequest.h

@@ -1,75 +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_SDDP_MODEL_DESCRIBEPRIVILEGESREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEPRIVILEGESREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribePrivilegesRequest : public RpcServiceRequest
-			{
-
-			public:
-				DescribePrivilegesRequest();
-				~DescribePrivilegesRequest();
-
-				int getAccountType()const;
-				void setAccountType(int accountType);
-				long getAccountId()const;
-				void setAccountId(long accountId);
-				std::string getSourceIp()const;
-				void setSourceIp(const std::string& sourceIp);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
-				std::string getLang()const;
-				void setLang(const std::string& lang);
-				std::string getKey()const;
-				void setKey(const std::string& key);
-				long getUseAccountId()const;
-				void setUseAccountId(long useAccountId);
-				int getFeatureType()const;
-				void setFeatureType(int featureType);
-				int getCurrentPage()const;
-				void setCurrentPage(int currentPage);
-				std::string getDataTypeIds()const;
-				void setDataTypeIds(const std::string& dataTypeIds);
-
-            private:
-				int accountType_;
-				long accountId_;
-				std::string sourceIp_;
-				int pageSize_;
-				std::string lang_;
-				std::string key_;
-				long useAccountId_;
-				int featureType_;
-				int currentPage_;
-				std::string dataTypeIds_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEPRIVILEGESREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribePrivilegesResult.h

@@ -1,79 +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_SDDP_MODEL_DESCRIBEPRIVILEGESRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEPRIVILEGESRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/sddp/SddpExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Sddp
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribePrivilegesResult : public ServiceResult
-			{
-			public:
-				struct Privilege
-				{
-					int useAccountType;
-					std::string dataTable;
-					std::string dataInstance;
-					long accountId;
-					std::string productName;
-					std::string productCode;
-					std::string resourceName;
-					std::string operation;
-					std::string policyCondition;
-					int accountType;
-					std::string resourcePath;
-					std::string dataTypeId;
-					std::string dataColumn;
-					std::string dataType;
-					std::string dataPackage;
-					std::string sensitive;
-					long id;
-					std::string dataTypeName;
-					long useAccountId;
-				};
-
-
-				DescribePrivilegesResult();
-				explicit DescribePrivilegesResult(const std::string &payload);
-				~DescribePrivilegesResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getCurrentPage()const;
-				std::vector<Privilege> getItems()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				int totalCount_;
-				int pageSize_;
-				int currentPage_;
-				std::vector<Privilege> items_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEPRIVILEGESRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeRiskLevelsRequest.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_SDDP_MODEL_DESCRIBERISKLEVELSREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBERISKLEVELSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT DescribeRiskLevelsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRiskLevelsRequest();
+				~DescribeRiskLevelsRequest();
+
+				int getCustomType()const;
+				void setCustomType(int customType);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				int customType_;
+				std::string sourceIp_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBERISKLEVELSREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeRiskLevelsResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDDATABASESRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDDATABASESRESULT_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBERISKLEVELSRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBERISKLEVELSRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,29 +29,31 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeCloudDatabasesResult : public ServiceResult
+			class ALIBABACLOUD_SDDP_EXPORT DescribeRiskLevelsResult : public ServiceResult
 			{
 			public:
-				struct CloudDatabase
+				struct RiskLevel
 				{
-					std::string instanceId;
-					std::string engine;
+					std::string description;
+					std::string alias;
+					long id;
+					int referenceNum;
 					std::string name;
 				};
 
 
-				DescribeCloudDatabasesResult();
-				explicit DescribeCloudDatabasesResult(const std::string &payload);
-				~DescribeCloudDatabasesResult();
-				std::vector<CloudDatabase> getCloudDatabaseList()const;
+				DescribeRiskLevelsResult();
+				explicit DescribeRiskLevelsResult(const std::string &payload);
+				~DescribeRiskLevelsResult();
+				std::vector<RiskLevel> getRiskLevelList()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<CloudDatabase> cloudDatabaseList_;
+				std::vector<RiskLevel> riskLevelList_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBECLOUDDATABASESRESULT_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBERISKLEVELSRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeRuleCategoryRequest.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_SDDP_MODEL_DESCRIBERULECATEGORYREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBERULECATEGORYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT DescribeRuleCategoryRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRuleCategoryRequest();
+				~DescribeRuleCategoryRequest();
+
+				long getProductId()const;
+				void setProductId(long productId);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				long productId_;
+				std::string sourceIp_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBERULECATEGORYREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeRuleCategoryResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEORIGINALLOGSRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEORIGINALLOGSRESULT_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBERULECATEGORYRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBERULECATEGORYRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,38 +29,43 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeOriginalLogsResult : public ServiceResult
+			class ALIBABACLOUD_SDDP_EXPORT DescribeRuleCategoryResult : public ServiceResult
 			{
 			public:
-				struct Log
+				struct Rule
 				{
-					struct LogContent
+					struct ChildRule
 					{
-						std::string value;
-						std::string key;
+						std::string parentId;
+						long id;
+						std::string groupId;
+						std::string name;
 					};
-					std::vector<Log::LogContent> logContents;
+					std::vector<Rule::ChildRule> childList;
+					std::string groupId;
+					std::string name;
+				};
+				struct Product
+				{
+					std::string value;
+					std::string label;
 				};
 
 
-				DescribeOriginalLogsResult();
-				explicit DescribeOriginalLogsResult(const std::string &payload);
-				~DescribeOriginalLogsResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getCurrentPage()const;
-				std::vector<Log> getItems()const;
+				DescribeRuleCategoryResult();
+				explicit DescribeRuleCategoryResult(const std::string &payload);
+				~DescribeRuleCategoryResult();
+				std::vector<Product> getProductList()const;
+				std::vector<Rule> getRuleList()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int totalCount_;
-				int pageSize_;
-				int currentPage_;
-				std::vector<Log> items_;
+				std::vector<Product> productList_;
+				std::vector<Rule> ruleList_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEORIGINALLOGSRESULT_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBERULECATEGORYRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeRulesRequest.h

@@ -49,8 +49,14 @@ namespace AlibabaCloud
 				void setPageSize(int pageSize);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				bool getKeywordCompatible()const;
+				void setKeywordCompatible(bool keywordCompatible);
 				int getRuleType()const;
 				void setRuleType(int ruleType);
+				std::string getGroupId()const;
+				void setGroupId(const std::string& groupId);
+				int getContentCategory()const;
+				void setContentCategory(int contentCategory);
 				int getCurrentPage()const;
 				void setCurrentPage(int currentPage);
 				int getCustomType()const;
@@ -59,6 +65,8 @@ namespace AlibabaCloud
 				void setName(const std::string& name);
 				int getCategory()const;
 				void setCategory(int category);
+				int getStatus()const;
+				void setStatus(int status);
 
             private:
 				int warnLevel_;
@@ -68,11 +76,15 @@ namespace AlibabaCloud
 				std::string sourceIp_;
 				int pageSize_;
 				std::string lang_;
+				bool keywordCompatible_;
 				int ruleType_;
+				std::string groupId_;
+				int contentCategory_;
 				int currentPage_;
 				int customType_;
 				std::string name_;
 				int category_;
+				int status_;
 
 			};
 		}

sddp/include/alibabacloud/sddp/model/DescribeRulesResult.h

@@ -34,27 +34,31 @@ namespace AlibabaCloud
 			public:
 				struct Rule
 				{
-					int customType;
-					int status;
 					std::string loginName;
 					std::string description;
 					int category;
-					std::string productCode;
 					long gmtModified;
 					std::string statExpress;
 					long productId;
 					long riskLevelId;
-					std::string departName;
 					std::string name;
-					int hitTotalCount;
-					long gmtCreate;
+					std::string target;
 					int warnLevel;
+					std::string displayName;
+					int customType;
+					int status;
+					std::string productCode;
+					std::string departName;
+					int hitTotalCount;
+					std::string majorKey;
+					std::string groupId;
+					long gmtCreate;
 					long userId;
 					std::string content;
-					std::string displayName;
 					std::string categoryName;
 					std::string riskLevelName;
 					long id;
+					std::string contentCategory;
 				};
 
 

sddp/include/alibabacloud/sddp/model/DescribeTablesRequest.h

@@ -41,28 +41,50 @@ namespace AlibabaCloud
 				void setProductId(long productId);
 				std::string getRiskLevels()const;
 				void setRiskLevels(const std::string& riskLevels);
+				bool getNeedRiskCount()const;
+				void setNeedRiskCount(bool needRiskCount);
 				long getPackageId()const;
 				void setPackageId(long packageId);
+				std::string getRuleName()const;
+				void setRuleName(const std::string& ruleName);
 				std::string getQueryName()const;
 				void setQueryName(const std::string& queryName);
 				long getRiskLevelId()const;
 				void setRiskLevelId(long riskLevelId);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				long getLastScanTimeEnd()const;
+				void setLastScanTimeEnd(long lastScanTimeEnd);
+				long getLastScanTimeStart()const;
+				void setLastScanTimeStart(long lastScanTimeStart);
+				std::string getSensLevelName()const;
+				void setSensLevelName(const std::string& sensLevelName);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
+				std::string getInstanceDescription()const;
+				void setInstanceDescription(const std::string& instanceDescription);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
 				int getQueryType()const;
 				void setQueryType(int queryType);
+				std::string getServiceRegionId()const;
+				void setServiceRegionId(const std::string& serviceRegionId);
 				int getFeatureType()const;
 				void setFeatureType(int featureType);
 				std::string getOrderBy()const;
 				void setOrderBy(const std::string& orderBy);
+				long getEndTime()const;
+				void setEndTime(long endTime);
 				int getCurrentPage()const;
 				void setCurrentPage(int currentPage);
+				std::string getRuleIds()const;
+				void setRuleIds(const std::string& ruleIds);
 				long getInstanceId()const;
 				void setInstanceId(long instanceId);
+				std::string getInstanceName()const;
+				void setInstanceName(const std::string& instanceName);
 				std::string getName()const;
 				void setName(const std::string& name);
 				long getRuleId()const;
@@ -72,17 +94,28 @@ namespace AlibabaCloud
 				std::string productCode_;
 				long productId_;
 				std::string riskLevels_;
+				bool needRiskCount_;
 				long packageId_;
+				std::string ruleName_;
 				std::string queryName_;
 				long riskLevelId_;
+				long startTime_;
+				long lastScanTimeEnd_;
+				long lastScanTimeStart_;
+				std::string sensLevelName_;
 				std::string sourceIp_;
 				int pageSize_;
+				std::string instanceDescription_;
 				std::string lang_;
 				int queryType_;
+				std::string serviceRegionId_;
 				int featureType_;
 				std::string orderBy_;
+				long endTime_;
 				int currentPage_;
+				std::string ruleIds_;
 				long instanceId_;
+				std::string instanceName_;
 				std::string name_;
 				long ruleId_;
 

sddp/include/alibabacloud/sddp/model/DescribeTablesResult.h

@@ -34,21 +34,36 @@ namespace AlibabaCloud
 			public:
 				struct Table
 				{
+					struct Rule
+					{
+						std::string displayName;
+						long count;
+						long riskLevelId;
+						std::string name;
+					};
+					std::vector<Table::Rule> ruleList;
 					std::string owner;
-					std::string productCode;
-					long instanceId;
-					std::string sensitiveRatio;
 					std::string productId;
 					int s2Count;
-					long lastScanTime;
 					long riskLevelId;
-					std::string departName;
 					std::string name;
-					int totalCount;
 					int totalRows;
-					long creationTime;
+					std::string regionName;
+					int s1Count;
 					bool sensitive;
+					std::string productCode;
+					long instanceId;
+					std::string tenantName;
+					std::string sensitiveRatio;
+					std::string countDetails;
+					long lastScanTime;
+					std::string departName;
+					std::string instanceName;
+					int totalCount;
+					std::string sensLevelName;
+					long creationTime;
 					std::string riskLevelName;
+					std::string instanceDescription;
 					long id;
 					int sensitiveCount;
 					int s3Count;

sddp/include/alibabacloud/sddp/model/DescribeUserCountRequest.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_SDDP_MODEL_DESCRIBEUSERCOUNTREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSERCOUNTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT DescribeUserCountRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeUserCountRequest();
+				~DescribeUserCountRequest();
+
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string sourceIp_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSERCOUNTREQUEST_H_

sddp/include/alibabacloud/sddp/model/DescribeUserCountResult.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_SDDP_MODEL_DESCRIBEUSERCOUNTRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSERCOUNTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT DescribeUserCountResult : public ServiceResult
+			{
+			public:
+				struct UserCount
+				{
+					int totalAuthCount;
+					long warnAddCount;
+					bool authed;
+					int unAuthCount;
+					std::string saleInstanceId;
+					int saleInstanceStatus;
+					bool buyed;
+					long warnTotalCount;
+					int authCount;
+				};
+
+
+				DescribeUserCountResult();
+				explicit DescribeUserCountResult(const std::string &payload);
+				~DescribeUserCountResult();
+				UserCount getUserCount()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				UserCount userCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSERCOUNTRESULT_H_

sddp/include/alibabacloud/sddp/model/DescribeUserStatusResult.h

@@ -34,19 +34,43 @@ namespace AlibabaCloud
 			public:
 				struct UserStatus
 				{
-					bool rdsSet;
-					std::string instanceId;
+					int labStatus;
+					long totalDataMaskColumns;
 					bool renewStatus;
 					int instanceNum;
+					long dataMaskTasks;
+					long dlpCount;
+					long dlpTotalCount;
+					long ossSize;
+					std::string version;
+					int instanceStatus;
+					long sensitiveTable;
+					bool ossBucketSet;
+					std::string displayTime;
+					std::string sensitiveTop;
+					std::string sensitiveTotalTop;
+					bool odpsSet;
+					long sensitiveTables;
+					bool buyed;
+					long incSensitiveTables;
+					std::string authProductList;
+					long alarmCount;
+					int dbAuditStatus;
+					long datamaskColumns;
+					bool rdsSet;
+					std::string instanceId;
+					long dataMaskColumns;
+					bool auditUpgradeStatus;
+					long sensitiveObjects;
 					bool trail;
 					bool authed;
-					long ossSize;
 					long useOssSize;
+					long divulgeCount;
 					std::string accessKeyId;
-					int instanceStatus;
-					bool ossBucketSet;
-					bool odpsSet;
-					bool buyed;
+					std::string chargeType;
+					long incSensitiveObjects;
+					bool assetScanned;
+					long sensitiveObject;
 					int remainDays;
 					int useInstanceNum;
 				};

sddp/include/alibabacloud/sddp/model/DisableUserConfigRequest.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_SDDP_MODEL_DISABLEUSERCONFIGREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_DISABLEUSERCONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/sddp/SddpExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sddp
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SDDP_EXPORT DisableUserConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				DisableUserConfigRequest();
+				~DisableUserConfigRequest();
+
+				std::string getCode()const;
+				void setCode(const std::string& code);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string code_;
+				std::string sourceIp_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SDDP_MODEL_DISABLEUSERCONFIGREQUEST_H_

sddp/include/alibabacloud/sddp/model/DisableUserConfigResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_VALIDATECONNECTORRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_VALIDATECONNECTORRESULT_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_DISABLEUSERCONFIGRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_DISABLEUSERCONFIGRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,23 +29,21 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT ValidateConnectorResult : public ServiceResult
+			class ALIBABACLOUD_SDDP_EXPORT DisableUserConfigResult : public ServiceResult
 			{
 			public:
 
 
-				ValidateConnectorResult();
-				explicit ValidateConnectorResult(const std::string &payload);
-				~ValidateConnectorResult();
-				bool getConnected()const;
+				DisableUserConfigResult();
+				explicit DisableUserConfigResult(const std::string &payload);
+				~DisableUserConfigResult();
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				bool connected_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_VALIDATECONNECTORRESULT_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_DISABLEUSERCONFIGRESULT_H_

sddp/include/alibabacloud/sddp/model/ModifyEventStatusRequest.h

@@ -39,6 +39,8 @@ namespace AlibabaCloud
 				void setBacked(bool backed);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
+				std::string getHandleInfo()const;
+				void setHandleInfo(const std::string& handleInfo);
 				std::string getDealReason()const;
 				void setDealReason(const std::string& dealReason);
 				long getId()const;
@@ -53,6 +55,7 @@ namespace AlibabaCloud
             private:
 				bool backed_;
 				std::string sourceIp_;
+				std::string handleInfo_;
 				std::string dealReason_;
 				long id_;
 				std::string lang_;

sddp/include/alibabacloud/sddp/model/ModifyRuleRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setProductCode(const std::string& productCode);
 				long getProductId()const;
 				void setProductId(long productId);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
 				long getRiskLevelId()const;
 				void setRiskLevelId(long riskLevelId);
 				std::string getContent()const;
@@ -57,8 +59,12 @@ namespace AlibabaCloud
 				void setRuleType(int ruleType);
 				std::string getStatExpress()const;
 				void setStatExpress(const std::string& statExpress);
+				int getContentCategory()const;
+				void setContentCategory(int contentCategory);
 				int getCustomType()const;
 				void setCustomType(int customType);
+				std::string getTarget()const;
+				void setTarget(const std::string& target);
 				std::string getName()const;
 				void setName(const std::string& name);
 				int getCategory()const;
@@ -68,6 +74,7 @@ namespace AlibabaCloud
 				int warnLevel_;
 				std::string productCode_;
 				long productId_;
+				std::string description_;
 				long riskLevelId_;
 				std::string content_;
 				std::string sourceIp_;
@@ -76,7 +83,9 @@ namespace AlibabaCloud
 				int featureType_;
 				int ruleType_;
 				std::string statExpress_;
+				int contentCategory_;
 				int customType_;
+				std::string target_;
 				std::string name_;
 				int category_;
 

sddp/include/alibabacloud/sddp/model/ModifyRuleStatusRequest.h

@@ -39,6 +39,8 @@ namespace AlibabaCloud
 				void setFeatureType(int featureType);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
+				std::string getIds()const;
+				void setIds(const std::string& ids);
 				long getId()const;
 				void setId(long id);
 				std::string getLang()const;
@@ -49,6 +51,7 @@ namespace AlibabaCloud
             private:
 				int featureType_;
 				std::string sourceIp_;
+				std::string ids_;
 				long id_;
 				std::string lang_;
 				int status_;

sddp/include/alibabacloud/sddp/model/ModifyRuleStatusResult.h

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

sddp/include/alibabacloud/sddp/model/StopMaskingProcessRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSEFLOWREQUEST_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSEFLOWREQUEST_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_STOPMASKINGPROCESSREQUEST_H_
+#define ALIBABACLOUD_SDDP_MODEL_STOPMASKINGPROCESSREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,33 +28,30 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeUseFlowRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SDDP_EXPORT StopMaskingProcessRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeUseFlowRequest();
-				~DescribeUseFlowRequest();
+				StopMaskingProcessRequest();
+				~StopMaskingProcessRequest();
 
-				std::string getDateType()const;
-				void setDateType(const std::string& dateType);
-				int getFeatureType()const;
-				void setFeatureType(int featureType);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
-				int getDays()const;
-				void setDays(int days);
+				long getId()const;
+				void setId(long id);
 				std::string getLang()const;
 				void setLang(const std::string& lang);
+				int getFeatureType()const;
+				void setFeatureType(int featureType);
 
             private:
-				std::string dateType_;
-				int featureType_;
 				std::string sourceIp_;
-				int days_;
+				long id_;
 				std::string lang_;
+				int featureType_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSEFLOWREQUEST_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_STOPMASKINGPROCESSREQUEST_H_

sddp/include/alibabacloud/sddp/model/StopMaskingProcessResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSEFLOWRESULT_H_
-#define ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSEFLOWRESULT_H_
+#ifndef ALIBABACLOUD_SDDP_MODEL_STOPMASKINGPROCESSRESULT_H_
+#define ALIBABACLOUD_SDDP_MODEL_STOPMASKINGPROCESSRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,31 +29,21 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SDDP_EXPORT DescribeUseFlowResult : public ServiceResult
+			class ALIBABACLOUD_SDDP_EXPORT StopMaskingProcessResult : public ServiceResult
 			{
 			public:
-				struct UseFlow
-				{
-					long sddpCredits;
-					long tableNum;
-					int saleFlowCountType;
-					long ossSize;
-					long dataMaskCells;
-				};
 
 
-				DescribeUseFlowResult();
-				explicit DescribeUseFlowResult(const std::string &payload);
-				~DescribeUseFlowResult();
-				UseFlow getUseFlow()const;
+				StopMaskingProcessResult();
+				explicit StopMaskingProcessResult(const std::string &payload);
+				~StopMaskingProcessResult();
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				UseFlow useFlow_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SDDP_MODEL_DESCRIBEUSEFLOWRESULT_H_
+#endif // !ALIBABACLOUD_SDDP_MODEL_STOPMASKINGPROCESSRESULT_H_

sddp/src/SddpClient.cc

@@ -31,26 +31,62 @@ SddpClient::SddpClient(const Credentials &credentials, const ClientConfiguration
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "sddp");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 SddpClient::SddpClient(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, "sddp");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 SddpClient::SddpClient(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, "sddp");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 SddpClient::~SddpClient()
 {}
 
+SddpClient::BatchDeleteDataLimitOutcome SddpClient::batchDeleteDataLimit(const BatchDeleteDataLimitRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BatchDeleteDataLimitOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BatchDeleteDataLimitOutcome(BatchDeleteDataLimitResult(outcome.result()));
+	else
+		return BatchDeleteDataLimitOutcome(outcome.error());
+}
+
+void SddpClient::batchDeleteDataLimitAsync(const BatchDeleteDataLimitRequest& request, const BatchDeleteDataLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, batchDeleteDataLimit(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SddpClient::BatchDeleteDataLimitOutcomeCallable SddpClient::batchDeleteDataLimitCallable(const BatchDeleteDataLimitRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BatchDeleteDataLimitOutcome()>>(
+			[this, request]()
+			{
+			return this->batchDeleteDataLimit(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SddpClient::CreateConfigOutcome SddpClient::createConfig(const CreateConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,36 +195,36 @@ SddpClient::CreateRuleOutcomeCallable SddpClient::createRuleCallable(const Creat
 	return task->get_future();
 }
 
-SddpClient::CreateUserAuthOutcome SddpClient::createUserAuth(const CreateUserAuthRequest &request) const
+SddpClient::CreateScanTaskOutcome SddpClient::createScanTask(const CreateScanTaskRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateUserAuthOutcome(endpointOutcome.error());
+		return CreateScanTaskOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateUserAuthOutcome(CreateUserAuthResult(outcome.result()));
+		return CreateScanTaskOutcome(CreateScanTaskResult(outcome.result()));
 	else
-		return CreateUserAuthOutcome(outcome.error());
+		return CreateScanTaskOutcome(outcome.error());
 }
 
-void SddpClient::createUserAuthAsync(const CreateUserAuthRequest& request, const CreateUserAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SddpClient::createScanTaskAsync(const CreateScanTaskRequest& request, const CreateScanTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createUserAuth(request), context);
+		handler(this, request, createScanTask(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SddpClient::CreateUserAuthOutcomeCallable SddpClient::createUserAuthCallable(const CreateUserAuthRequest &request) const
+SddpClient::CreateScanTaskOutcomeCallable SddpClient::createScanTaskCallable(const CreateScanTaskRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateUserAuthOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateScanTaskOutcome()>>(
 			[this, request]()
 			{
-			return this->createUserAuth(request);
+			return this->createScanTask(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -339,150 +375,6 @@ SddpClient::DescribeAccountsOutcomeCallable SddpClient::describeAccountsCallable
 	return task->get_future();
 }
 
-SddpClient::DescribeAuditLogsOutcome SddpClient::describeAuditLogs(const DescribeAuditLogsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeAuditLogsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeAuditLogsOutcome(DescribeAuditLogsResult(outcome.result()));
-	else
-		return DescribeAuditLogsOutcome(outcome.error());
-}
-
-void SddpClient::describeAuditLogsAsync(const DescribeAuditLogsRequest& request, const DescribeAuditLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeAuditLogs(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::DescribeAuditLogsOutcomeCallable SddpClient::describeAuditLogsCallable(const DescribeAuditLogsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeAuditLogsOutcome()>>(
-			[this, request]()
-			{
-			return this->describeAuditLogs(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-SddpClient::DescribeAuthAccountsOutcome SddpClient::describeAuthAccounts(const DescribeAuthAccountsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeAuthAccountsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeAuthAccountsOutcome(DescribeAuthAccountsResult(outcome.result()));
-	else
-		return DescribeAuthAccountsOutcome(outcome.error());
-}
-
-void SddpClient::describeAuthAccountsAsync(const DescribeAuthAccountsRequest& request, const DescribeAuthAccountsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeAuthAccounts(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::DescribeAuthAccountsOutcomeCallable SddpClient::describeAuthAccountsCallable(const DescribeAuthAccountsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeAuthAccountsOutcome()>>(
-			[this, request]()
-			{
-			return this->describeAuthAccounts(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-SddpClient::DescribeCloudDatabasesOutcome SddpClient::describeCloudDatabases(const DescribeCloudDatabasesRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeCloudDatabasesOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeCloudDatabasesOutcome(DescribeCloudDatabasesResult(outcome.result()));
-	else
-		return DescribeCloudDatabasesOutcome(outcome.error());
-}
-
-void SddpClient::describeCloudDatabasesAsync(const DescribeCloudDatabasesRequest& request, const DescribeCloudDatabasesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeCloudDatabases(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::DescribeCloudDatabasesOutcomeCallable SddpClient::describeCloudDatabasesCallable(const DescribeCloudDatabasesRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeCloudDatabasesOutcome()>>(
-			[this, request]()
-			{
-			return this->describeCloudDatabases(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-SddpClient::DescribeCloudInstancesOutcome SddpClient::describeCloudInstances(const DescribeCloudInstancesRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeCloudInstancesOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeCloudInstancesOutcome(DescribeCloudInstancesResult(outcome.result()));
-	else
-		return DescribeCloudInstancesOutcome(outcome.error());
-}
-
-void SddpClient::describeCloudInstancesAsync(const DescribeCloudInstancesRequest& request, const DescribeCloudInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeCloudInstances(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::DescribeCloudInstancesOutcomeCallable SddpClient::describeCloudInstancesCallable(const DescribeCloudInstancesRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeCloudInstancesOutcome()>>(
-			[this, request]()
-			{
-			return this->describeCloudInstances(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 SddpClient::DescribeColumnsOutcome SddpClient::describeColumns(const DescribeColumnsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -591,150 +483,6 @@ SddpClient::DescribeDataAssetsOutcomeCallable SddpClient::describeDataAssetsCall
 	return task->get_future();
 }
 
-SddpClient::DescribeDataHubConnectorsOutcome SddpClient::describeDataHubConnectors(const DescribeDataHubConnectorsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeDataHubConnectorsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeDataHubConnectorsOutcome(DescribeDataHubConnectorsResult(outcome.result()));
-	else
-		return DescribeDataHubConnectorsOutcome(outcome.error());
-}
-
-void SddpClient::describeDataHubConnectorsAsync(const DescribeDataHubConnectorsRequest& request, const DescribeDataHubConnectorsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeDataHubConnectors(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::DescribeDataHubConnectorsOutcomeCallable SddpClient::describeDataHubConnectorsCallable(const DescribeDataHubConnectorsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeDataHubConnectorsOutcome()>>(
-			[this, request]()
-			{
-			return this->describeDataHubConnectors(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-SddpClient::DescribeDataHubProjectsOutcome SddpClient::describeDataHubProjects(const DescribeDataHubProjectsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeDataHubProjectsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeDataHubProjectsOutcome(DescribeDataHubProjectsResult(outcome.result()));
-	else
-		return DescribeDataHubProjectsOutcome(outcome.error());
-}
-
-void SddpClient::describeDataHubProjectsAsync(const DescribeDataHubProjectsRequest& request, const DescribeDataHubProjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeDataHubProjects(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::DescribeDataHubProjectsOutcomeCallable SddpClient::describeDataHubProjectsCallable(const DescribeDataHubProjectsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeDataHubProjectsOutcome()>>(
-			[this, request]()
-			{
-			return this->describeDataHubProjects(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-SddpClient::DescribeDataHubSubscriptionsOutcome SddpClient::describeDataHubSubscriptions(const DescribeDataHubSubscriptionsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeDataHubSubscriptionsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeDataHubSubscriptionsOutcome(DescribeDataHubSubscriptionsResult(outcome.result()));
-	else
-		return DescribeDataHubSubscriptionsOutcome(outcome.error());
-}
-
-void SddpClient::describeDataHubSubscriptionsAsync(const DescribeDataHubSubscriptionsRequest& request, const DescribeDataHubSubscriptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeDataHubSubscriptions(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::DescribeDataHubSubscriptionsOutcomeCallable SddpClient::describeDataHubSubscriptionsCallable(const DescribeDataHubSubscriptionsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeDataHubSubscriptionsOutcome()>>(
-			[this, request]()
-			{
-			return this->describeDataHubSubscriptions(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-SddpClient::DescribeDataHubTopicsOutcome SddpClient::describeDataHubTopics(const DescribeDataHubTopicsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeDataHubTopicsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeDataHubTopicsOutcome(DescribeDataHubTopicsResult(outcome.result()));
-	else
-		return DescribeDataHubTopicsOutcome(outcome.error());
-}
-
-void SddpClient::describeDataHubTopicsAsync(const DescribeDataHubTopicsRequest& request, const DescribeDataHubTopicsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeDataHubTopics(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::DescribeDataHubTopicsOutcomeCallable SddpClient::describeDataHubTopicsCallable(const DescribeDataHubTopicsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeDataHubTopicsOutcome()>>(
-			[this, request]()
-			{
-			return this->describeDataHubTopics(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 SddpClient::DescribeDataLimitDetailOutcome SddpClient::describeDataLimitDetail(const DescribeDataLimitDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -771,6 +519,42 @@ SddpClient::DescribeDataLimitDetailOutcomeCallable SddpClient::describeDataLimit
 	return task->get_future();
 }
 
+SddpClient::DescribeDataLimitSetOutcome SddpClient::describeDataLimitSet(const DescribeDataLimitSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDataLimitSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDataLimitSetOutcome(DescribeDataLimitSetResult(outcome.result()));
+	else
+		return DescribeDataLimitSetOutcome(outcome.error());
+}
+
+void SddpClient::describeDataLimitSetAsync(const DescribeDataLimitSetRequest& request, const DescribeDataLimitSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDataLimitSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SddpClient::DescribeDataLimitSetOutcomeCallable SddpClient::describeDataLimitSetCallable(const DescribeDataLimitSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDataLimitSetOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDataLimitSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SddpClient::DescribeDataLimitsOutcome SddpClient::describeDataLimits(const DescribeDataLimitsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +591,42 @@ SddpClient::DescribeDataLimitsOutcomeCallable SddpClient::describeDataLimitsCall
 	return task->get_future();
 }
 
+SddpClient::DescribeDataLimitsInstanceDimOutcome SddpClient::describeDataLimitsInstanceDim(const DescribeDataLimitsInstanceDimRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDataLimitsInstanceDimOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDataLimitsInstanceDimOutcome(DescribeDataLimitsInstanceDimResult(outcome.result()));
+	else
+		return DescribeDataLimitsInstanceDimOutcome(outcome.error());
+}
+
+void SddpClient::describeDataLimitsInstanceDimAsync(const DescribeDataLimitsInstanceDimRequest& request, const DescribeDataLimitsInstanceDimAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDataLimitsInstanceDim(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SddpClient::DescribeDataLimitsInstanceDimOutcomeCallable SddpClient::describeDataLimitsInstanceDimCallable(const DescribeDataLimitsInstanceDimRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDataLimitsInstanceDimOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDataLimitsInstanceDim(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SddpClient::DescribeDataMaskingRunHistoryOutcome SddpClient::describeDataMaskingRunHistory(const DescribeDataMaskingRunHistoryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,36 +699,36 @@ SddpClient::DescribeDataMaskingTasksOutcomeCallable SddpClient::describeDataMask
 	return task->get_future();
 }
 
-SddpClient::DescribeDepartsOutcome SddpClient::describeDeparts(const DescribeDepartsRequest &request) const
+SddpClient::DescribeDataTotalCountOutcome SddpClient::describeDataTotalCount(const DescribeDataTotalCountRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeDepartsOutcome(endpointOutcome.error());
+		return DescribeDataTotalCountOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeDepartsOutcome(DescribeDepartsResult(outcome.result()));
+		return DescribeDataTotalCountOutcome(DescribeDataTotalCountResult(outcome.result()));
 	else
-		return DescribeDepartsOutcome(outcome.error());
+		return DescribeDataTotalCountOutcome(outcome.error());
 }
 
-void SddpClient::describeDepartsAsync(const DescribeDepartsRequest& request, const DescribeDepartsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SddpClient::describeDataTotalCountAsync(const DescribeDataTotalCountRequest& request, const DescribeDataTotalCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeDeparts(request), context);
+		handler(this, request, describeDataTotalCount(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SddpClient::DescribeDepartsOutcomeCallable SddpClient::describeDepartsCallable(const DescribeDepartsRequest &request) const
+SddpClient::DescribeDataTotalCountOutcomeCallable SddpClient::describeDataTotalCountCallable(const DescribeDataTotalCountRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeDepartsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DescribeDataTotalCountOutcome()>>(
 			[this, request]()
 			{
-			return this->describeDeparts(request);
+			return this->describeDataTotalCount(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -951,6 +771,42 @@ SddpClient::DescribeEventDetailOutcomeCallable SddpClient::describeEventDetailCa
 	return task->get_future();
 }
 
+SddpClient::DescribeEventTopOutcome SddpClient::describeEventTop(const DescribeEventTopRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeEventTopOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeEventTopOutcome(DescribeEventTopResult(outcome.result()));
+	else
+		return DescribeEventTopOutcome(outcome.error());
+}
+
+void SddpClient::describeEventTopAsync(const DescribeEventTopRequest& request, const DescribeEventTopAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeEventTop(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SddpClient::DescribeEventTopOutcomeCallable SddpClient::describeEventTopCallable(const DescribeEventTopRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeEventTopOutcome()>>(
+			[this, request]()
+			{
+			return this->describeEventTop(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SddpClient::DescribeEventTypesOutcome SddpClient::describeEventTypes(const DescribeEventTypesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -987,6 +843,42 @@ SddpClient::DescribeEventTypesOutcomeCallable SddpClient::describeEventTypesCall
 	return task->get_future();
 }
 
+SddpClient::DescribeEventTypesDetailOutcome SddpClient::describeEventTypesDetail(const DescribeEventTypesDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeEventTypesDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeEventTypesDetailOutcome(DescribeEventTypesDetailResult(outcome.result()));
+	else
+		return DescribeEventTypesDetailOutcome(outcome.error());
+}
+
+void SddpClient::describeEventTypesDetailAsync(const DescribeEventTypesDetailRequest& request, const DescribeEventTypesDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeEventTypesDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SddpClient::DescribeEventTypesDetailOutcomeCallable SddpClient::describeEventTypesDetailCallable(const DescribeEventTypesDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeEventTypesDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->describeEventTypesDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SddpClient::DescribeEventsOutcome SddpClient::describeEvents(const DescribeEventsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1023,6 +915,78 @@ SddpClient::DescribeEventsOutcomeCallable SddpClient::describeEventsCallable(con
 	return task->get_future();
 }
 
+SddpClient::DescribeInstancePortraitOutcome SddpClient::describeInstancePortrait(const DescribeInstancePortraitRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeInstancePortraitOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeInstancePortraitOutcome(DescribeInstancePortraitResult(outcome.result()));
+	else
+		return DescribeInstancePortraitOutcome(outcome.error());
+}
+
+void SddpClient::describeInstancePortraitAsync(const DescribeInstancePortraitRequest& request, const DescribeInstancePortraitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeInstancePortrait(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SddpClient::DescribeInstancePortraitOutcomeCallable SddpClient::describeInstancePortraitCallable(const DescribeInstancePortraitRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeInstancePortraitOutcome()>>(
+			[this, request]()
+			{
+			return this->describeInstancePortrait(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SddpClient::DescribeInstanceSourcesOutcome SddpClient::describeInstanceSources(const DescribeInstanceSourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeInstanceSourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeInstanceSourcesOutcome(DescribeInstanceSourcesResult(outcome.result()));
+	else
+		return DescribeInstanceSourcesOutcome(outcome.error());
+}
+
+void SddpClient::describeInstanceSourcesAsync(const DescribeInstanceSourcesRequest& request, const DescribeInstanceSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeInstanceSources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SddpClient::DescribeInstanceSourcesOutcomeCallable SddpClient::describeInstanceSourcesCallable(const DescribeInstanceSourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeInstanceSourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeInstanceSources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SddpClient::DescribeInstancesOutcome SddpClient::describeInstances(const DescribeInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,42 +1023,6 @@ SddpClient::DescribeInstancesOutcomeCallable SddpClient::describeInstancesCallab
 	return task->get_future();
 }
 
-SddpClient::DescribeOriginalLogsOutcome SddpClient::describeOriginalLogs(const DescribeOriginalLogsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeOriginalLogsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeOriginalLogsOutcome(DescribeOriginalLogsResult(outcome.result()));
-	else
-		return DescribeOriginalLogsOutcome(outcome.error());
-}
-
-void SddpClient::describeOriginalLogsAsync(const DescribeOriginalLogsRequest& request, const DescribeOriginalLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeOriginalLogs(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::DescribeOriginalLogsOutcomeCallable SddpClient::describeOriginalLogsCallable(const DescribeOriginalLogsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeOriginalLogsOutcome()>>(
-			[this, request]()
-			{
-			return this->describeOriginalLogs(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 SddpClient::DescribeOssObjectDetailOutcome SddpClient::describeOssObjectDetail(const DescribeOssObjectDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1203,36 +1131,72 @@ SddpClient::DescribePackagesOutcomeCallable SddpClient::describePackagesCallable
 	return task->get_future();
 }
 
-SddpClient::DescribePrivilegesOutcome SddpClient::describePrivileges(const DescribePrivilegesRequest &request) const
+SddpClient::DescribeRiskLevelsOutcome SddpClient::describeRiskLevels(const DescribeRiskLevelsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribePrivilegesOutcome(endpointOutcome.error());
+		return DescribeRiskLevelsOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribePrivilegesOutcome(DescribePrivilegesResult(outcome.result()));
+		return DescribeRiskLevelsOutcome(DescribeRiskLevelsResult(outcome.result()));
 	else
-		return DescribePrivilegesOutcome(outcome.error());
+		return DescribeRiskLevelsOutcome(outcome.error());
 }
 
-void SddpClient::describePrivilegesAsync(const DescribePrivilegesRequest& request, const DescribePrivilegesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SddpClient::describeRiskLevelsAsync(const DescribeRiskLevelsRequest& request, const DescribeRiskLevelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describePrivileges(request), context);
+		handler(this, request, describeRiskLevels(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SddpClient::DescribePrivilegesOutcomeCallable SddpClient::describePrivilegesCallable(const DescribePrivilegesRequest &request) const
+SddpClient::DescribeRiskLevelsOutcomeCallable SddpClient::describeRiskLevelsCallable(const DescribeRiskLevelsRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribePrivilegesOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DescribeRiskLevelsOutcome()>>(
 			[this, request]()
 			{
-			return this->describePrivileges(request);
+			return this->describeRiskLevels(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SddpClient::DescribeRuleCategoryOutcome SddpClient::describeRuleCategory(const DescribeRuleCategoryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRuleCategoryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRuleCategoryOutcome(DescribeRuleCategoryResult(outcome.result()));
+	else
+		return DescribeRuleCategoryOutcome(outcome.error());
+}
+
+void SddpClient::describeRuleCategoryAsync(const DescribeRuleCategoryRequest& request, const DescribeRuleCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRuleCategory(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SddpClient::DescribeRuleCategoryOutcomeCallable SddpClient::describeRuleCategoryCallable(const DescribeRuleCategoryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRuleCategoryOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRuleCategory(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -1311,36 +1275,36 @@ SddpClient::DescribeTablesOutcomeCallable SddpClient::describeTablesCallable(con
 	return task->get_future();
 }
 
-SddpClient::DescribeUseFlowOutcome SddpClient::describeUseFlow(const DescribeUseFlowRequest &request) const
+SddpClient::DescribeUserCountOutcome SddpClient::describeUserCount(const DescribeUserCountRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeUseFlowOutcome(endpointOutcome.error());
+		return DescribeUserCountOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeUseFlowOutcome(DescribeUseFlowResult(outcome.result()));
+		return DescribeUserCountOutcome(DescribeUserCountResult(outcome.result()));
 	else
-		return DescribeUseFlowOutcome(outcome.error());
+		return DescribeUserCountOutcome(outcome.error());
 }
 
-void SddpClient::describeUseFlowAsync(const DescribeUseFlowRequest& request, const DescribeUseFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SddpClient::describeUserCountAsync(const DescribeUserCountRequest& request, const DescribeUserCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeUseFlow(request), context);
+		handler(this, request, describeUserCount(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SddpClient::DescribeUseFlowOutcomeCallable SddpClient::describeUseFlowCallable(const DescribeUseFlowRequest &request) const
+SddpClient::DescribeUserCountOutcomeCallable SddpClient::describeUserCountCallable(const DescribeUserCountRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeUseFlowOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DescribeUserCountOutcome()>>(
 			[this, request]()
 			{
-			return this->describeUseFlow(request);
+			return this->describeUserCount(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -1383,6 +1347,42 @@ SddpClient::DescribeUserStatusOutcomeCallable SddpClient::describeUserStatusCall
 	return task->get_future();
 }
 
+SddpClient::DisableUserConfigOutcome SddpClient::disableUserConfig(const DisableUserConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableUserConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableUserConfigOutcome(DisableUserConfigResult(outcome.result()));
+	else
+		return DisableUserConfigOutcome(outcome.error());
+}
+
+void SddpClient::disableUserConfigAsync(const DisableUserConfigRequest& request, const DisableUserConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableUserConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SddpClient::DisableUserConfigOutcomeCallable SddpClient::disableUserConfigCallable(const DisableUserConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableUserConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->disableUserConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SddpClient::ExecDatamaskOutcome SddpClient::execDatamask(const ExecDatamaskRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,72 +1671,36 @@ SddpClient::ModifyRuleStatusOutcomeCallable SddpClient::modifyRuleStatusCallable
 	return task->get_future();
 }
 
-SddpClient::ModifySaleFlowCountTypeOutcome SddpClient::modifySaleFlowCountType(const ModifySaleFlowCountTypeRequest &request) const
+SddpClient::StopMaskingProcessOutcome SddpClient::stopMaskingProcess(const StopMaskingProcessRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return ModifySaleFlowCountTypeOutcome(endpointOutcome.error());
+		return StopMaskingProcessOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return ModifySaleFlowCountTypeOutcome(ModifySaleFlowCountTypeResult(outcome.result()));
+		return StopMaskingProcessOutcome(StopMaskingProcessResult(outcome.result()));
 	else
-		return ModifySaleFlowCountTypeOutcome(outcome.error());
+		return StopMaskingProcessOutcome(outcome.error());
 }
 
-void SddpClient::modifySaleFlowCountTypeAsync(const ModifySaleFlowCountTypeRequest& request, const ModifySaleFlowCountTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SddpClient::stopMaskingProcessAsync(const StopMaskingProcessRequest& request, const StopMaskingProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, modifySaleFlowCountType(request), context);
+		handler(this, request, stopMaskingProcess(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SddpClient::ModifySaleFlowCountTypeOutcomeCallable SddpClient::modifySaleFlowCountTypeCallable(const ModifySaleFlowCountTypeRequest &request) const
+SddpClient::StopMaskingProcessOutcomeCallable SddpClient::stopMaskingProcessCallable(const StopMaskingProcessRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<ModifySaleFlowCountTypeOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<StopMaskingProcessOutcome()>>(
 			[this, request]()
 			{
-			return this->modifySaleFlowCountType(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-SddpClient::ValidateConnectorOutcome SddpClient::validateConnector(const ValidateConnectorRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return ValidateConnectorOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return ValidateConnectorOutcome(ValidateConnectorResult(outcome.result()));
-	else
-		return ValidateConnectorOutcome(outcome.error());
-}
-
-void SddpClient::validateConnectorAsync(const ValidateConnectorRequest& request, const ValidateConnectorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, validateConnector(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SddpClient::ValidateConnectorOutcomeCallable SddpClient::validateConnectorCallable(const ValidateConnectorRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<ValidateConnectorOutcome()>>(
-			[this, request]()
-			{
-			return this->validateConnector(request);
+			return this->stopMaskingProcess(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

sddp/src/model/BatchDeleteDataLimitRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sddp/model/BatchDeleteDataLimitRequest.h>
+
+using AlibabaCloud::Sddp::Model::BatchDeleteDataLimitRequest;
+
+BatchDeleteDataLimitRequest::BatchDeleteDataLimitRequest() :
+	RpcServiceRequest("sddp", "2019-01-03", "BatchDeleteDataLimit")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+BatchDeleteDataLimitRequest::~BatchDeleteDataLimitRequest()
+{}
+
+long BatchDeleteDataLimitRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void BatchDeleteDataLimitRequest::setResourceType(long resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", std::to_string(resourceType));
+}
+
+std::string BatchDeleteDataLimitRequest::getSourceIp()const
+{
+	return sourceIp_;
+}
+
+void BatchDeleteDataLimitRequest::setSourceIp(const std::string& sourceIp)
+{
+	sourceIp_ = sourceIp;
+	setParameter("SourceIp", sourceIp);
+}
+
+std::string BatchDeleteDataLimitRequest::getDataLimitList()const
+{
+	return dataLimitList_;
+}
+
+void BatchDeleteDataLimitRequest::setDataLimitList(const std::string& dataLimitList)
+{
+	dataLimitList_ = dataLimitList;
+	setParameter("DataLimitList", dataLimitList);
+}
+

sddp/src/model/BatchDeleteDataLimitResult.cc

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

sddp/src/model/CreateConfigResult.cc

@@ -39,6 +39,13 @@ void CreateConfigResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["Id"].isNull())
+		id_ = std::stol(value["Id"].asString());
 
 }
 
+long CreateConfigResult::getId()const
+{
+	return id_;
+}
+

sddp/src/model/CreateDataLimitRequest.cc

@@ -27,6 +27,17 @@ CreateDataLimitRequest::CreateDataLimitRequest() :
 CreateDataLimitRequest::~CreateDataLimitRequest()
 {}
 
+int CreateDataLimitRequest::getOcrStatus()const
+{
+	return ocrStatus_;
+}
+
+void CreateDataLimitRequest::setOcrStatus(int ocrStatus)
+{
+	ocrStatus_ = ocrStatus;
+	setParameter("OcrStatus", std::to_string(ocrStatus));
+}
+
 std::string CreateDataLimitRequest::getParentId()const
 {
 	return parentId_;
@@ -181,6 +192,17 @@ void CreateDataLimitRequest::setPort(int port)
 	setParameter("Port", std::to_string(port));
 }
 
+int CreateDataLimitRequest::getEventStatus()const
+{
+	return eventStatus_;
+}
+
+void CreateDataLimitRequest::setEventStatus(int eventStatus)
+{
+	eventStatus_ = eventStatus;
+	setParameter("EventStatus", std::to_string(eventStatus));
+}
+
 std::string CreateDataLimitRequest::getUserName()const
 {
 	return userName_;

sddp/src/model/CreateRuleRequest.cc

@@ -60,6 +60,17 @@ void CreateRuleRequest::setProductId(long productId)
 	setParameter("ProductId", std::to_string(productId));
 }
 
+std::string CreateRuleRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateRuleRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
 long CreateRuleRequest::getRiskLevelId()const
 {
 	return riskLevelId_;
@@ -137,6 +148,17 @@ void CreateRuleRequest::setStatExpress(const std::string& statExpress)
 	setParameter("StatExpress", statExpress);
 }
 
+int CreateRuleRequest::getContentCategory()const
+{
+	return contentCategory_;
+}
+
+void CreateRuleRequest::setContentCategory(int contentCategory)
+{
+	contentCategory_ = contentCategory;
+	setParameter("ContentCategory", std::to_string(contentCategory));
+}
+
 long CreateRuleRequest::getCustomType()const
 {
 	return customType_;
@@ -148,6 +170,17 @@ void CreateRuleRequest::setCustomType(long customType)
 	setParameter("CustomType", std::to_string(customType));
 }
 
+std::string CreateRuleRequest::getTarget()const
+{
+	return target_;
+}
+
+void CreateRuleRequest::setTarget(const std::string& target)
+{
+	target_ = target;
+	setParameter("Target", target);
+}
+
 std::string CreateRuleRequest::getName()const
 {
 	return name_;
@@ -170,3 +203,14 @@ void CreateRuleRequest::setCategory(int category)
 	setParameter("Category", std::to_string(category));
 }
 
+int CreateRuleRequest::getStatus()const
+{
+	return status_;
+}
+
+void CreateRuleRequest::setStatus(int status)
+{
+	status_ = status;
+	setParameter("Status", std::to_string(status));
+}
+

sddp/src/model/CreateScanTaskRequest.cc

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/sddp/model/CreateScanTaskRequest.h>
+
+using AlibabaCloud::Sddp::Model::CreateScanTaskRequest;
+
+CreateScanTaskRequest::CreateScanTaskRequest() :
+	RpcServiceRequest("sddp", "2019-01-03", "CreateScanTask")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateScanTaskRequest::~CreateScanTaskRequest()
+{}
+
+int CreateScanTaskRequest::getRunHour()const
+{
+	return runHour_;
+}
+
+void CreateScanTaskRequest::setRunHour(int runHour)
+{
+	runHour_ = runHour;
+	setParameter("RunHour", std::to_string(runHour));
+}
+
+std::string CreateScanTaskRequest::getScanRangeContent()const
+{
+	return scanRangeContent_;
+}
+
+void CreateScanTaskRequest::setScanRangeContent(const std::string& scanRangeContent)
+{
+	scanRangeContent_ = scanRangeContent;
+	setParameter("ScanRangeContent", scanRangeContent);
+}
+
+std::string CreateScanTaskRequest::getTaskName()const
+{
+	return taskName_;
+}
+
+void CreateScanTaskRequest::setTaskName(const std::string& taskName)
+{
+	taskName_ = taskName;
+	setParameter("TaskName", taskName);
+}
+
+long CreateScanTaskRequest::getDataLimitId()const
+{
+	return dataLimitId_;
+}
+
+void CreateScanTaskRequest::setDataLimitId(long dataLimitId)
+{
+	dataLimitId_ = dataLimitId;
+	setParameter("DataLimitId", std::to_string(dataLimitId));
+}
+
+int CreateScanTaskRequest::getRunMinute()const
+{
+	return runMinute_;
+}
+
+void CreateScanTaskRequest::setRunMinute(int runMinute)
+{
+	runMinute_ = runMinute;
+	setParameter("RunMinute", std::to_string(runMinute));
+}
+
+std::string CreateScanTaskRequest::getSourceIp()const
+{
+	return sourceIp_;
+}
+
+void CreateScanTaskRequest::setSourceIp(const std::string& sourceIp)
+{
+	sourceIp_ = sourceIp;
+	setParameter("SourceIp", sourceIp);
+}
+
+int CreateScanTaskRequest::getIntervalDay()const
+{
+	return intervalDay_;
+}
+
+void CreateScanTaskRequest::setIntervalDay(int intervalDay)
+{
+	intervalDay_ = intervalDay;
+	setParameter("IntervalDay", std::to_string(intervalDay));
+}
+
+int CreateScanTaskRequest::getScanRange()const
+{
+	return scanRange_;
+}
+
+void CreateScanTaskRequest::setScanRange(int scanRange)
+{
+	scanRange_ = scanRange;
+	setParameter("ScanRange", std::to_string(scanRange));
+}
+
+std::string CreateScanTaskRequest::getOssScanPath()const
+{
+	return ossScanPath_;
+}
+
+void CreateScanTaskRequest::setOssScanPath(const std::string& ossScanPath)
+{
+	ossScanPath_ = ossScanPath;
+	setParameter("OssScanPath", ossScanPath);
+}
+
+long CreateScanTaskRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void CreateScanTaskRequest::setResourceType(long resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", std::to_string(resourceType));
+}
+
+std::string CreateScanTaskRequest::getTaskUserName()const
+{
+	return taskUserName_;
+}
+
+void CreateScanTaskRequest::setTaskUserName(const std::string& taskUserName)
+{
+	taskUserName_ = taskUserName;
+	setParameter("TaskUserName", taskUserName);
+}
+

sddp/src/model/CreateScanTaskResult.cc

@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/sddp/model/ValidateConnectorResult.h>
+#include <alibabacloud/sddp/model/CreateScanTaskResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Sddp;
 using namespace AlibabaCloud::Sddp::Model;
 
-ValidateConnectorResult::ValidateConnectorResult() :
+CreateScanTaskResult::CreateScanTaskResult() :
 	ServiceResult()
 {}
 
-ValidateConnectorResult::ValidateConnectorResult(const std::string &payload) :
+CreateScanTaskResult::CreateScanTaskResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-ValidateConnectorResult::~ValidateConnectorResult()
+CreateScanTaskResult::~CreateScanTaskResult()
 {}
 
-void ValidateConnectorResult::parse(const std::string &payload)
+void CreateScanTaskResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Connected"].isNull())
-		connected_ = value["Connected"].asString() == "true";
+	if(!value["Id"].isNull())
+		id_ = std::stoi(value["Id"].asString());
 
 }
 
-bool ValidateConnectorResult::getConnected()const
+int CreateScanTaskResult::getId()const
 {
-	return connected_;
+	return id_;
 }
 

sddp/src/model/CreateUserAuthRequest.cc

@@ -1,82 +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/sddp/model/CreateUserAuthRequest.h>
-
-using AlibabaCloud::Sddp::Model::CreateUserAuthRequest;
-
-CreateUserAuthRequest::CreateUserAuthRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "CreateUserAuth")
-{}
-
-CreateUserAuthRequest::~CreateUserAuthRequest()
-{}
-
-std::string CreateUserAuthRequest::getAccessKeySecret()const
-{
-	return accessKeySecret_;
-}
-
-void CreateUserAuthRequest::setAccessKeySecret(const std::string& accessKeySecret)
-{
-	accessKeySecret_ = accessKeySecret;
-	setCoreParameter("AccessKeySecret", accessKeySecret);
-}
-
-long CreateUserAuthRequest::getAccountId()const
-{
-	return accountId_;
-}
-
-void CreateUserAuthRequest::setAccountId(long accountId)
-{
-	accountId_ = accountId;
-	setCoreParameter("AccountId", std::to_string(accountId));
-}
-
-std::string CreateUserAuthRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void CreateUserAuthRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setCoreParameter("SourceIp", sourceIp);
-}
-
-std::string CreateUserAuthRequest::getAccessKey()const
-{
-	return accessKey_;
-}
-
-void CreateUserAuthRequest::setAccessKey(const std::string& accessKey)
-{
-	accessKey_ = accessKey;
-	setCoreParameter("AccessKey", accessKey);
-}
-
-std::string CreateUserAuthRequest::getLang()const
-{
-	return lang_;
-}
-
-void CreateUserAuthRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setCoreParameter("Lang", lang);
-}
-

sddp/src/model/DescribeAuditLogsRequest.cc

@@ -1,172 +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/sddp/model/DescribeAuditLogsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeAuditLogsRequest;
-
-DescribeAuditLogsRequest::DescribeAuditLogsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeAuditLogs")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAuditLogsRequest::~DescribeAuditLogsRequest()
-{}
-
-int DescribeAuditLogsRequest::getProductCode()const
-{
-	return productCode_;
-}
-
-void DescribeAuditLogsRequest::setProductCode(int productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", std::to_string(productCode));
-}
-
-long DescribeAuditLogsRequest::getProductId()const
-{
-	return productId_;
-}
-
-void DescribeAuditLogsRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
-}
-
-long DescribeAuditLogsRequest::getStartTime()const
-{
-	return startTime_;
-}
-
-void DescribeAuditLogsRequest::setStartTime(long startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", std::to_string(startTime));
-}
-
-std::string DescribeAuditLogsRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeAuditLogsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-std::string DescribeAuditLogsRequest::getClientIp()const
-{
-	return clientIp_;
-}
-
-void DescribeAuditLogsRequest::setClientIp(const std::string& clientIp)
-{
-	clientIp_ = clientIp;
-	setParameter("ClientIp", clientIp);
-}
-
-int DescribeAuditLogsRequest::getPageSize()const
-{
-	return pageSize_;
-}
-
-void DescribeAuditLogsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
-}
-
-std::string DescribeAuditLogsRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeAuditLogsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-
-int DescribeAuditLogsRequest::getFeatureType()const
-{
-	return featureType_;
-}
-
-void DescribeAuditLogsRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
-}
-
-long DescribeAuditLogsRequest::getEndTime()const
-{
-	return endTime_;
-}
-
-void DescribeAuditLogsRequest::setEndTime(long endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", std::to_string(endTime));
-}
-
-int DescribeAuditLogsRequest::getCurrentPage()const
-{
-	return currentPage_;
-}
-
-void DescribeAuditLogsRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
-}
-
-std::string DescribeAuditLogsRequest::getClientUa()const
-{
-	return clientUa_;
-}
-
-void DescribeAuditLogsRequest::setClientUa(const std::string& clientUa)
-{
-	clientUa_ = clientUa;
-	setParameter("ClientUa", clientUa);
-}
-
-std::string DescribeAuditLogsRequest::getInstanceName()const
-{
-	return instanceName_;
-}
-
-void DescribeAuditLogsRequest::setInstanceName(const std::string& instanceName)
-{
-	instanceName_ = instanceName;
-	setParameter("InstanceName", instanceName);
-}
-
-std::string DescribeAuditLogsRequest::getUserName()const
-{
-	return userName_;
-}
-
-void DescribeAuditLogsRequest::setUserName(const std::string& userName)
-{
-	userName_ = userName;
-	setParameter("UserName", userName);
-}
-

sddp/src/model/DescribeAuditLogsResult.cc

@@ -1,122 +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/sddp/model/DescribeAuditLogsResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeAuditLogsResult::DescribeAuditLogsResult() :
-	ServiceResult()
-{}
-
-DescribeAuditLogsResult::DescribeAuditLogsResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeAuditLogsResult::~DescribeAuditLogsResult()
-{}
-
-void DescribeAuditLogsResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allItemsNode = value["Items"]["Log"];
-	for (auto valueItemsLog : allItemsNode)
-	{
-		Log itemsObject;
-		if(!valueItemsLog["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsLog["Id"].asString());
-		if(!valueItemsLog["ProductCode"].isNull())
-			itemsObject.productCode = valueItemsLog["ProductCode"].asString();
-		if(!valueItemsLog["ProductId"].isNull())
-			itemsObject.productId = std::stol(valueItemsLog["ProductId"].asString());
-		if(!valueItemsLog["LogTime"].isNull())
-			itemsObject.logTime = std::stol(valueItemsLog["LogTime"].asString());
-		if(!valueItemsLog["UserId"].isNull())
-			itemsObject.userId = valueItemsLog["UserId"].asString();
-		if(!valueItemsLog["UserName"].isNull())
-			itemsObject.userName = valueItemsLog["UserName"].asString();
-		if(!valueItemsLog["ClientIp"].isNull())
-			itemsObject.clientIp = valueItemsLog["ClientIp"].asString();
-		if(!valueItemsLog["ClientPort"].isNull())
-			itemsObject.clientPort = valueItemsLog["ClientPort"].asString();
-		if(!valueItemsLog["ClientUa"].isNull())
-			itemsObject.clientUa = valueItemsLog["ClientUa"].asString();
-		if(!valueItemsLog["InstanceName"].isNull())
-			itemsObject.instanceName = valueItemsLog["InstanceName"].asString();
-		if(!valueItemsLog["CreationTime"].isNull())
-			itemsObject.creationTime = std::stol(valueItemsLog["CreationTime"].asString());
-		if(!valueItemsLog["DatabaseName"].isNull())
-			itemsObject.databaseName = valueItemsLog["DatabaseName"].asString();
-		if(!valueItemsLog["TableName"].isNull())
-			itemsObject.tableName = valueItemsLog["TableName"].asString();
-		if(!valueItemsLog["ColumnName"].isNull())
-			itemsObject.columnName = valueItemsLog["ColumnName"].asString();
-		if(!valueItemsLog["PackageName"].isNull())
-			itemsObject.packageName = valueItemsLog["PackageName"].asString();
-		if(!valueItemsLog["OssObjectKey"].isNull())
-			itemsObject.ossObjectKey = valueItemsLog["OssObjectKey"].asString();
-		if(!valueItemsLog["ExecuteTime"].isNull())
-			itemsObject.executeTime = std::stol(valueItemsLog["ExecuteTime"].asString());
-		if(!valueItemsLog["EffectRow"].isNull())
-			itemsObject.effectRow = std::stol(valueItemsLog["EffectRow"].asString());
-		if(!valueItemsLog["OperateType"].isNull())
-			itemsObject.operateType = valueItemsLog["OperateType"].asString();
-		if(!valueItemsLog["RuleId"].isNull())
-			itemsObject.ruleId = valueItemsLog["RuleId"].asString();
-		if(!valueItemsLog["RuleName"].isNull())
-			itemsObject.ruleName = valueItemsLog["RuleName"].asString();
-		if(!valueItemsLog["WarnLevel"].isNull())
-			itemsObject.warnLevel = valueItemsLog["WarnLevel"].asString();
-		if(!valueItemsLog["ExecuteStatus"].isNull())
-			itemsObject.executeStatus = std::stoi(valueItemsLog["ExecuteStatus"].asString());
-		items_.push_back(itemsObject);
-	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
-	if(!value["CurrentPage"].isNull())
-		currentPage_ = std::stoi(value["CurrentPage"].asString());
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
-
-}
-
-int DescribeAuditLogsResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeAuditLogsResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeAuditLogsResult::getCurrentPage()const
-{
-	return currentPage_;
-}
-
-std::vector<DescribeAuditLogsResult::Log> DescribeAuditLogsResult::getItems()const
-{
-	return items_;
-}
-

sddp/src/model/DescribeAuthAccountsRequest.cc

@@ -1,84 +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/sddp/model/DescribeAuthAccountsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeAuthAccountsRequest;
-
-DescribeAuthAccountsRequest::DescribeAuthAccountsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeAuthAccounts")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAuthAccountsRequest::~DescribeAuthAccountsRequest()
-{}
-
-int DescribeAuthAccountsRequest::getFeatureType()const
-{
-	return featureType_;
-}
-
-void DescribeAuthAccountsRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
-}
-
-int DescribeAuthAccountsRequest::getCurrentPage()const
-{
-	return currentPage_;
-}
-
-void DescribeAuthAccountsRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
-}
-
-std::string DescribeAuthAccountsRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeAuthAccountsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-int DescribeAuthAccountsRequest::getPageSize()const
-{
-	return pageSize_;
-}
-
-void DescribeAuthAccountsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
-}
-
-std::string DescribeAuthAccountsRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeAuthAccountsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-

sddp/src/model/DescribeAuthAccountsResult.cc

@@ -1,88 +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/sddp/model/DescribeAuthAccountsResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeAuthAccountsResult::DescribeAuthAccountsResult() :
-	ServiceResult()
-{}
-
-DescribeAuthAccountsResult::DescribeAuthAccountsResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeAuthAccountsResult::~DescribeAuthAccountsResult()
-{}
-
-void DescribeAuthAccountsResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allItemsNode = value["Items"]["Account"];
-	for (auto valueItemsAccount : allItemsNode)
-	{
-		Account itemsObject;
-		if(!valueItemsAccount["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsAccount["Id"].asString());
-		if(!valueItemsAccount["LoginName"].isNull())
-			itemsObject.loginName = valueItemsAccount["LoginName"].asString();
-		if(!valueItemsAccount["FullName"].isNull())
-			itemsObject.fullName = valueItemsAccount["FullName"].asString();
-		if(!valueItemsAccount["AuthLoginName"].isNull())
-			itemsObject.authLoginName = valueItemsAccount["AuthLoginName"].asString();
-		if(!valueItemsAccount["AuthFullName"].isNull())
-			itemsObject.authFullName = valueItemsAccount["AuthFullName"].asString();
-		if(!valueItemsAccount["AuthTime"].isNull())
-			itemsObject.authTime = std::stol(valueItemsAccount["AuthTime"].asString());
-		items_.push_back(itemsObject);
-	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
-	if(!value["CurrentPage"].isNull())
-		currentPage_ = std::stoi(value["CurrentPage"].asString());
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
-
-}
-
-int DescribeAuthAccountsResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeAuthAccountsResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeAuthAccountsResult::getCurrentPage()const
-{
-	return currentPage_;
-}
-
-std::vector<DescribeAuthAccountsResult::Account> DescribeAuthAccountsResult::getItems()const
-{
-	return items_;
-}
-