Supports tag management APIs.

1. add .clang-format code style file.
2. format code of core.

use `clang-format -i -style=file ./core/*/*.cc ./core/*/*.h` command to format

.clang-format

@@ -0,0 +1,137 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveMacros: false
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+    SortPriority:    0
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentCaseLabels: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+Standard:        Latest
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        8
+UseCRLF:         false
+UseTab:          Never
+...
+

CHANGELOG

@@ -1,3 +1,41 @@
+2020-07-03 Version: 1.36.498
+- Supports tag management APIs.
+
+2020-07-03 Version: 1.36.497
+- Add PicUrl parameter for picture related API.
+
+2020-07-03 Version: 1.36.496
+- Add PicUrl parameter for picture related API.
+
+2020-07-02 Version: 1.36.495
+- Generated 2020-05-18 for `dataworks-public`.
+
+2020-07-02 Version: 1.36.494
+- Add GetFootwearPosition.
+- Add PullTakeShoesEvent.
+- Add PullTryOnShoesEvent.
+
+2020-07-02 Version: 1.36.493
+- Add GetFootwearPosition.
+- Add PullTakeShoesEvent.
+- Add PullTryOnShoesEvent.
+
+2020-07-02 Version: 1.36.492
+- Update endpoint.
+
+2020-07-02 Version: 1.36.491
+- CreateShardingDBInstance add ProtocolType, to support DynamoDB.
+- DescribeDBInstances add return ResourceGroupId.
+
+2020-07-01 Version: 1.36.490
+- Add ListFace-MotorAlgorithmResults API.
+
+2020-07-01 Version: 1.36.489
+- Add API for GetMetadataAmount.
+
+2020-07-01 Version: 1.36.488
+- Support Saf For ExecuteExtendService.
+
 2020-06-30 Version: 1.36.487
 - Add ListMetrics API.
 

CMakeLists.txt

@@ -61,6 +61,8 @@ endif()
 
 if(BUILD_PRODUCT STREQUAL "")
   message(WARNING   "Please set the value of 'BUILD_PRODUCT'")
+elseif(BUILD_PRODUCT STREQUAL "core")
+  add_subdirectory(core)
 else()
   add_subdirectory(core)
   add_subdirectory(${BUILD_PRODUCT})

VERSION

@@ -1 +1 @@
-1.36.487
+1.36.498

amqp-open/CMakeLists.txt

@@ -37,6 +37,8 @@ set(amqp-open_public_header_model
 	include/alibabacloud/amqp-open/model/DeleteQueueResult.h
 	include/alibabacloud/amqp-open/model/DeleteVirtualHostRequest.h
 	include/alibabacloud/amqp-open/model/DeleteVirtualHostResult.h
+	include/alibabacloud/amqp-open/model/GetMetadataAmountRequest.h
+	include/alibabacloud/amqp-open/model/GetMetadataAmountResult.h
 	include/alibabacloud/amqp-open/model/ListBindingsRequest.h
 	include/alibabacloud/amqp-open/model/ListBindingsResult.h
 	include/alibabacloud/amqp-open/model/ListDownStreamBindingsRequest.h
@@ -47,6 +49,8 @@ set(amqp-open_public_header_model
 	include/alibabacloud/amqp-open/model/ListExchangesResult.h
 	include/alibabacloud/amqp-open/model/ListInstancesRequest.h
 	include/alibabacloud/amqp-open/model/ListInstancesResult.h
+	include/alibabacloud/amqp-open/model/ListQueueConsumersRequest.h
+	include/alibabacloud/amqp-open/model/ListQueueConsumersResult.h
 	include/alibabacloud/amqp-open/model/ListQueueUpStreamBindingsRequest.h
 	include/alibabacloud/amqp-open/model/ListQueueUpStreamBindingsResult.h
 	include/alibabacloud/amqp-open/model/ListQueuesRequest.h
@@ -72,6 +76,8 @@ set(amqp-open_src
 	src/model/DeleteQueueResult.cc
 	src/model/DeleteVirtualHostRequest.cc
 	src/model/DeleteVirtualHostResult.cc
+	src/model/GetMetadataAmountRequest.cc
+	src/model/GetMetadataAmountResult.cc
 	src/model/ListBindingsRequest.cc
 	src/model/ListBindingsResult.cc
 	src/model/ListDownStreamBindingsRequest.cc
@@ -82,6 +88,8 @@ set(amqp-open_src
 	src/model/ListExchangesResult.cc
 	src/model/ListInstancesRequest.cc
 	src/model/ListInstancesResult.cc
+	src/model/ListQueueConsumersRequest.cc
+	src/model/ListQueueConsumersResult.cc
 	src/model/ListQueueUpStreamBindingsRequest.cc
 	src/model/ListQueueUpStreamBindingsResult.cc
 	src/model/ListQueuesRequest.cc

amqp-open/include/alibabacloud/amqp-open/Amqp_openClient.h

@@ -38,6 +38,8 @@
 #include "model/DeleteQueueResult.h"
 #include "model/DeleteVirtualHostRequest.h"
 #include "model/DeleteVirtualHostResult.h"
+#include "model/GetMetadataAmountRequest.h"
+#include "model/GetMetadataAmountResult.h"
 #include "model/ListBindingsRequest.h"
 #include "model/ListBindingsResult.h"
 #include "model/ListDownStreamBindingsRequest.h"
@@ -48,6 +50,8 @@
 #include "model/ListExchangesResult.h"
 #include "model/ListInstancesRequest.h"
 #include "model/ListInstancesResult.h"
+#include "model/ListQueueConsumersRequest.h"
+#include "model/ListQueueConsumersResult.h"
 #include "model/ListQueueUpStreamBindingsRequest.h"
 #include "model/ListQueueUpStreamBindingsResult.h"
 #include "model/ListQueuesRequest.h"
@@ -87,6 +91,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteVirtualHostResult> DeleteVirtualHostOutcome;
 			typedef std::future<DeleteVirtualHostOutcome> DeleteVirtualHostOutcomeCallable;
 			typedef std::function<void(const Amqp_openClient*, const Model::DeleteVirtualHostRequest&, const DeleteVirtualHostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVirtualHostAsyncHandler;
+			typedef Outcome<Error, Model::GetMetadataAmountResult> GetMetadataAmountOutcome;
+			typedef std::future<GetMetadataAmountOutcome> GetMetadataAmountOutcomeCallable;
+			typedef std::function<void(const Amqp_openClient*, const Model::GetMetadataAmountRequest&, const GetMetadataAmountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetadataAmountAsyncHandler;
 			typedef Outcome<Error, Model::ListBindingsResult> ListBindingsOutcome;
 			typedef std::future<ListBindingsOutcome> ListBindingsOutcomeCallable;
 			typedef std::function<void(const Amqp_openClient*, const Model::ListBindingsRequest&, const ListBindingsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListBindingsAsyncHandler;
@@ -102,6 +109,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListInstancesResult> ListInstancesOutcome;
 			typedef std::future<ListInstancesOutcome> ListInstancesOutcomeCallable;
 			typedef std::function<void(const Amqp_openClient*, const Model::ListInstancesRequest&, const ListInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesAsyncHandler;
+			typedef Outcome<Error, Model::ListQueueConsumersResult> ListQueueConsumersOutcome;
+			typedef std::future<ListQueueConsumersOutcome> ListQueueConsumersOutcomeCallable;
+			typedef std::function<void(const Amqp_openClient*, const Model::ListQueueConsumersRequest&, const ListQueueConsumersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListQueueConsumersAsyncHandler;
 			typedef Outcome<Error, Model::ListQueueUpStreamBindingsResult> ListQueueUpStreamBindingsOutcome;
 			typedef std::future<ListQueueUpStreamBindingsOutcome> ListQueueUpStreamBindingsOutcomeCallable;
 			typedef std::function<void(const Amqp_openClient*, const Model::ListQueueUpStreamBindingsRequest&, const ListQueueUpStreamBindingsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListQueueUpStreamBindingsAsyncHandler;
@@ -140,6 +150,9 @@ namespace AlibabaCloud
 			DeleteVirtualHostOutcome deleteVirtualHost(const Model::DeleteVirtualHostRequest &request)const;
 			void deleteVirtualHostAsync(const Model::DeleteVirtualHostRequest& request, const DeleteVirtualHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteVirtualHostOutcomeCallable deleteVirtualHostCallable(const Model::DeleteVirtualHostRequest& request) const;
+			GetMetadataAmountOutcome getMetadataAmount(const Model::GetMetadataAmountRequest &request)const;
+			void getMetadataAmountAsync(const Model::GetMetadataAmountRequest& request, const GetMetadataAmountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetadataAmountOutcomeCallable getMetadataAmountCallable(const Model::GetMetadataAmountRequest& request) const;
 			ListBindingsOutcome listBindings(const Model::ListBindingsRequest &request)const;
 			void listBindingsAsync(const Model::ListBindingsRequest& request, const ListBindingsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListBindingsOutcomeCallable listBindingsCallable(const Model::ListBindingsRequest& request) const;
@@ -155,6 +168,9 @@ namespace AlibabaCloud
 			ListInstancesOutcome listInstances(const Model::ListInstancesRequest &request)const;
 			void listInstancesAsync(const Model::ListInstancesRequest& request, const ListInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListInstancesOutcomeCallable listInstancesCallable(const Model::ListInstancesRequest& request) const;
+			ListQueueConsumersOutcome listQueueConsumers(const Model::ListQueueConsumersRequest &request)const;
+			void listQueueConsumersAsync(const Model::ListQueueConsumersRequest& request, const ListQueueConsumersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListQueueConsumersOutcomeCallable listQueueConsumersCallable(const Model::ListQueueConsumersRequest& request) const;
 			ListQueueUpStreamBindingsOutcome listQueueUpStreamBindings(const Model::ListQueueUpStreamBindingsRequest &request)const;
 			void listQueueUpStreamBindingsAsync(const Model::ListQueueUpStreamBindingsRequest& request, const ListQueueUpStreamBindingsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListQueueUpStreamBindingsOutcomeCallable listQueueUpStreamBindingsCallable(const Model::ListQueueUpStreamBindingsRequest& request) const;

amqp-open/include/alibabacloud/amqp-open/model/GetMetadataAmountRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_AMQP_OPEN_MODEL_GETMETADATAAMOUNTREQUEST_H_
+#define ALIBABACLOUD_AMQP_OPEN_MODEL_GETMETADATAAMOUNTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/amqp-open/Amqp_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Amqp_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AMQP_OPEN_EXPORT GetMetadataAmountRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetMetadataAmountRequest();
+				~GetMetadataAmountRequest();
+
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AMQP_OPEN_MODEL_GETMETADATAAMOUNTREQUEST_H_

amqp-open/include/alibabacloud/amqp-open/model/GetMetadataAmountResult.h

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

amqp-open/include/alibabacloud/amqp-open/model/ListQueueConsumersRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_AMQP_OPEN_MODEL_LISTQUEUECONSUMERSREQUEST_H_
+#define ALIBABACLOUD_AMQP_OPEN_MODEL_LISTQUEUECONSUMERSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/amqp-open/Amqp_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Amqp_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AMQP_OPEN_EXPORT ListQueueConsumersRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListQueueConsumersRequest();
+				~ListQueueConsumersRequest();
+
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				int getQueryCount()const;
+				void setQueryCount(int queryCount);
+				std::string getVirtualHost()const;
+				void setVirtualHost(const std::string& virtualHost);
+				std::string getQueue()const;
+				void setQueue(const std::string& queue);
+
+            private:
+				std::string instanceId_;
+				std::string nextToken_;
+				int queryCount_;
+				std::string virtualHost_;
+				std::string queue_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AMQP_OPEN_MODEL_LISTQUEUECONSUMERSREQUEST_H_

amqp-open/include/alibabacloud/amqp-open/model/ListQueueConsumersResult.h

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

amqp-open/src/Amqp-openClient.cc

@@ -339,6 +339,42 @@ Amqp_openClient::DeleteVirtualHostOutcomeCallable Amqp_openClient::deleteVirtual
 	return task->get_future();
 }
 
+Amqp_openClient::GetMetadataAmountOutcome Amqp_openClient::getMetadataAmount(const GetMetadataAmountRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetMetadataAmountOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetMetadataAmountOutcome(GetMetadataAmountResult(outcome.result()));
+	else
+		return GetMetadataAmountOutcome(outcome.error());
+}
+
+void Amqp_openClient::getMetadataAmountAsync(const GetMetadataAmountRequest& request, const GetMetadataAmountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getMetadataAmount(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Amqp_openClient::GetMetadataAmountOutcomeCallable Amqp_openClient::getMetadataAmountCallable(const GetMetadataAmountRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetMetadataAmountOutcome()>>(
+			[this, request]()
+			{
+			return this->getMetadataAmount(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Amqp_openClient::ListBindingsOutcome Amqp_openClient::listBindings(const ListBindingsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -519,6 +555,42 @@ Amqp_openClient::ListInstancesOutcomeCallable Amqp_openClient::listInstancesCall
 	return task->get_future();
 }
 
+Amqp_openClient::ListQueueConsumersOutcome Amqp_openClient::listQueueConsumers(const ListQueueConsumersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListQueueConsumersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListQueueConsumersOutcome(ListQueueConsumersResult(outcome.result()));
+	else
+		return ListQueueConsumersOutcome(outcome.error());
+}
+
+void Amqp_openClient::listQueueConsumersAsync(const ListQueueConsumersRequest& request, const ListQueueConsumersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listQueueConsumers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Amqp_openClient::ListQueueConsumersOutcomeCallable Amqp_openClient::listQueueConsumersCallable(const ListQueueConsumersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListQueueConsumersOutcome()>>(
+			[this, request]()
+			{
+			return this->listQueueConsumers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Amqp_openClient::ListQueueUpStreamBindingsOutcome Amqp_openClient::listQueueUpStreamBindings(const ListQueueUpStreamBindingsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

amqp-open/src/model/GetMetadataAmountRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/amqp-open/model/GetMetadataAmountRequest.h>
+
+using AlibabaCloud::Amqp_open::Model::GetMetadataAmountRequest;
+
+GetMetadataAmountRequest::GetMetadataAmountRequest() :
+	RpcServiceRequest("amqp-open", "2019-12-12", "GetMetadataAmount")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+GetMetadataAmountRequest::~GetMetadataAmountRequest()
+{}
+
+std::string GetMetadataAmountRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void GetMetadataAmountRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

amqp-open/src/model/GetMetadataAmountResult.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/amqp-open/model/GetMetadataAmountResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Amqp_open;
+using namespace AlibabaCloud::Amqp_open::Model;
+
+GetMetadataAmountResult::GetMetadataAmountResult() :
+	ServiceResult()
+{}
+
+GetMetadataAmountResult::GetMetadataAmountResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetMetadataAmountResult::~GetMetadataAmountResult()
+{}
+
+void GetMetadataAmountResult::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["CurrentVirtualHosts"].isNull())
+		data_.currentVirtualHosts = std::stoi(dataNode["CurrentVirtualHosts"].asString());
+	if(!dataNode["MaxVirtualHosts"].isNull())
+		data_.maxVirtualHosts = std::stoi(dataNode["MaxVirtualHosts"].asString());
+	if(!dataNode["CurrentExchanges"].isNull())
+		data_.currentExchanges = std::stoi(dataNode["CurrentExchanges"].asString());
+	if(!dataNode["MaxExchanges"].isNull())
+		data_.maxExchanges = std::stoi(dataNode["MaxExchanges"].asString());
+	if(!dataNode["CurrentQueues"].isNull())
+		data_.currentQueues = std::stoi(dataNode["CurrentQueues"].asString());
+	if(!dataNode["MaxQueues"].isNull())
+		data_.maxQueues = std::stoi(dataNode["MaxQueues"].asString());
+
+}
+
+GetMetadataAmountResult::Data GetMetadataAmountResult::getData()const
+{
+	return data_;
+}
+

amqp-open/src/model/ListQueueConsumersRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/amqp-open/model/ListQueueConsumersRequest.h>
+
+using AlibabaCloud::Amqp_open::Model::ListQueueConsumersRequest;
+
+ListQueueConsumersRequest::ListQueueConsumersRequest() :
+	RpcServiceRequest("amqp-open", "2019-12-12", "ListQueueConsumers")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+ListQueueConsumersRequest::~ListQueueConsumersRequest()
+{}
+
+std::string ListQueueConsumersRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ListQueueConsumersRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string ListQueueConsumersRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void ListQueueConsumersRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+int ListQueueConsumersRequest::getQueryCount()const
+{
+	return queryCount_;
+}
+
+void ListQueueConsumersRequest::setQueryCount(int queryCount)
+{
+	queryCount_ = queryCount;
+	setParameter("QueryCount", std::to_string(queryCount));
+}
+
+std::string ListQueueConsumersRequest::getVirtualHost()const
+{
+	return virtualHost_;
+}
+
+void ListQueueConsumersRequest::setVirtualHost(const std::string& virtualHost)
+{
+	virtualHost_ = virtualHost;
+	setParameter("VirtualHost", virtualHost);
+}
+
+std::string ListQueueConsumersRequest::getQueue()const
+{
+	return queue_;
+}
+
+void ListQueueConsumersRequest::setQueue(const std::string& queue)
+{
+	queue_ = queue;
+	setParameter("Queue", queue);
+}
+

amqp-open/src/model/ListQueueConsumersResult.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/amqp-open/model/ListQueueConsumersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Amqp_open;
+using namespace AlibabaCloud::Amqp_open::Model;
+
+ListQueueConsumersResult::ListQueueConsumersResult() :
+	ServiceResult()
+{}
+
+ListQueueConsumersResult::ListQueueConsumersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListQueueConsumersResult::~ListQueueConsumersResult()
+{}
+
+void ListQueueConsumersResult::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["NextToken"].isNull())
+		data_.nextToken = dataNode["NextToken"].asString();
+	if(!dataNode["MaxResults"].isNull())
+		data_.maxResults = std::stoi(dataNode["MaxResults"].asString());
+	auto allConsumersNode = dataNode["Consumers"]["QueueConsumerVO"];
+	for (auto dataNodeConsumersQueueConsumerVO : allConsumersNode)
+	{
+		Data::QueueConsumerVO queueConsumerVOObject;
+		if(!dataNodeConsumersQueueConsumerVO["ConsumerTag"].isNull())
+			queueConsumerVOObject.consumerTag = dataNodeConsumersQueueConsumerVO["ConsumerTag"].asString();
+		data_.consumers.push_back(queueConsumerVOObject);
+	}
+
+}
+
+ListQueueConsumersResult::Data ListQueueConsumersResult::getData()const
+{
+	return data_;
+}
+

core/include/alibabacloud/core/ClientConfiguration.h

@@ -43,12 +43,16 @@ class ALIBABACLOUD_CORE_EXPORT ClientConfiguration {
   void setConnectTimeout(const long connectTimeout);
   void setReadTimeout(const long readTimeout);
 
+  bool rejectUnauthorized() const;
+  void setRejectUnauthorized(const bool rejectUnauthorized);
+
  private:
   std::string endpoint_;
   NetworkProxy proxy_;
   std::string regionId_;
   long connectTimeout_;
   long readTimeout_;
+  bool rejectUnauthorized_ = true;
 };
 }  // namespace AlibabaCloud
 

core/include/alibabacloud/core/HttpClient.h

@@ -34,9 +34,12 @@ class HttpClient {
   virtual HttpResponseOutcome makeRequest(const HttpRequest &request) = 0;
   NetworkProxy proxy()const;
   void setProxy(const NetworkProxy &proxy);
+  bool rejectUnauthorized()const;
+  void setRejectUnauthorized(const bool &rejectUnauthorized);
 
  private:
   NetworkProxy proxy_;
+  bool rejectUnauthorized_;
 };
 }  // namespace AlibabaCloud
 #endif  // CORE_INCLUDE_ALIBABACLOUD_CORE_HTTPCLIENT_H_

core/src/AlibabaCloud.cc

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/core/AlibabaCloud.h>
 #include "Executor.h"
+#include <alibabacloud/core/AlibabaCloud.h>
 
-static AlibabaCloud::Executor * executor = nullptr;
+static AlibabaCloud::Executor *executor = nullptr;
 
 void AlibabaCloud::InitializeSdk() {
   if (IsSdkInitialized())
@@ -27,9 +27,7 @@ void AlibabaCloud::InitializeSdk() {
   executor->start();
 }
 
-bool AlibabaCloud::IsSdkInitialized() {
-  return executor != nullptr;
-}
+bool AlibabaCloud::IsSdkInitialized() { return executor != nullptr; }
 
 void AlibabaCloud::ShutdownSdk() {
   if (!IsSdkInitialized())

core/src/AsyncCallerContext.cc

@@ -17,29 +17,16 @@
 #include <alibabacloud/core/AsyncCallerContext.h>
 #include <alibabacloud/core/Utils.h>
 
-namespace AlibabaCloud
-{
+namespace AlibabaCloud {
 
-AsyncCallerContext::AsyncCallerContext() : uuid_(GenerateUuid())
-{
-}
+AsyncCallerContext::AsyncCallerContext() : uuid_(GenerateUuid()) {}
 
-AsyncCallerContext::AsyncCallerContext(const std::string &uuid) : uuid_(uuid)
-{
-}
+AsyncCallerContext::AsyncCallerContext(const std::string &uuid) : uuid_(uuid) {}
 
-AsyncCallerContext::~AsyncCallerContext()
-{
-}
+AsyncCallerContext::~AsyncCallerContext() {}
 
-std::string AsyncCallerContext::uuid() const
-{
-  return uuid_;
-}
+std::string AsyncCallerContext::uuid() const { return uuid_; }
 
-void AsyncCallerContext::setUuid(const std::string &uuid)
-{
-  uuid_ = uuid;
-}
+void AsyncCallerContext::setUuid(const std::string &uuid) { uuid_ = uuid; }
 
 } // namespace AlibabaCloud

core/src/ClientConfiguration.cc

@@ -14,36 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/core/ClientConfiguration.h>
 #include <alibabacloud/core/AlibabaCloud.h>
+#include <alibabacloud/core/ClientConfiguration.h>
 
 namespace AlibabaCloud {
 
 ClientConfiguration::ClientConfiguration(const std::string &regionId,
-  const NetworkProxy &proxy):
-  regionId_(regionId),
-  proxy_(proxy),
-  endpoint_(),
-  connectTimeout_(kDefaultConnectTimeout),
-  readTimeout_(kDefaultReadTimeout) {
-}
+                                         const NetworkProxy &proxy)
+    : regionId_(regionId), proxy_(proxy), endpoint_(),
+      connectTimeout_(kDefaultConnectTimeout),
+      readTimeout_(kDefaultReadTimeout) {}
 
-ClientConfiguration::~ClientConfiguration() {
-}
+ClientConfiguration::~ClientConfiguration() {}
 
-std::string ClientConfiguration::endpoint() const {
-  return endpoint_;
-}
+std::string ClientConfiguration::endpoint() const { return endpoint_; }
 
-NetworkProxy ClientConfiguration::proxy()const {
-  return proxy_;
-}
+NetworkProxy ClientConfiguration::proxy() const { return proxy_; }
 
-std::string ClientConfiguration::regionId()const {
-  return regionId_;
-}
+std::string ClientConfiguration::regionId() const { return regionId_; }
 
-void ClientConfiguration::setEndpoint(const std::string & endpoint) {
+void ClientConfiguration::setEndpoint(const std::string &endpoint) {
   endpoint_ = endpoint;
 }
 
@@ -55,13 +45,9 @@ void ClientConfiguration::setRegionId(const std::string &regionId) {
   regionId_ = regionId;
 }
 
-long ClientConfiguration::connectTimeout() const {
-  return connectTimeout_;
-}
+long ClientConfiguration::connectTimeout() const { return connectTimeout_; }
 
-long ClientConfiguration::readTimeout() const {
-  return readTimeout_;
-}
+long ClientConfiguration::readTimeout() const { return readTimeout_; }
 
 void ClientConfiguration::setConnectTimeout(const long connectTimeout) {
   connectTimeout_ = connectTimeout;
@@ -71,4 +57,12 @@ void ClientConfiguration::setReadTimeout(const long readTimeout) {
   readTimeout_ = readTimeout;
 }
 
-}  // namespace AlibabaCloud
+bool ClientConfiguration::rejectUnauthorized() const {
+  return rejectUnauthorized_;
+}
+
+void ClientConfiguration::setRejectUnauthorized(const bool rejectUnauthorized) {
+  rejectUnauthorized_ = rejectUnauthorized;
+}
+
+} // namespace AlibabaCloud

core/src/CommonClient.cc

@@ -1,81 +1,73 @@
 /*
-* Copyright 1999-2019 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.
-*/
+ * Copyright 1999-2019 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 <algorithm>
 #include <alibabacloud/core/AlibabaCloud.h>
 #include <alibabacloud/core/CommonClient.h>
-#include <alibabacloud/core/location/LocationClient.h>
 #include <alibabacloud/core/SimpleCredentialsProvider.h>
+#include <alibabacloud/core/location/LocationClient.h>
 #include <ctime>
-#include <algorithm>
 #include <iomanip>
 #include <sstream>
 
 #include <alibabacloud/core/Utils.h>
 
-namespace AlibabaCloud
-{
+namespace AlibabaCloud {
 
-namespace
-{
+namespace {
 const std::string SERVICE_NAME = "Common";
 }
 
 CommonClient::CommonClient(const Credentials &credentials,
-                           const ClientConfiguration &configuration) : CoreClient(SERVICE_NAME, configuration),
-                                                                       credentialsProvider_(
-                                                                           std::make_shared<SimpleCredentialsProvider>(credentials)),
-                                                                       signer_(std::make_shared<HmacSha1Signer>())
-{
-}
+                           const ClientConfiguration &configuration)
+    : CoreClient(SERVICE_NAME, configuration),
+      credentialsProvider_(
+          std::make_shared<SimpleCredentialsProvider>(credentials)),
+      signer_(std::make_shared<HmacSha1Signer>()) {}
 
 CommonClient::CommonClient(
     const std::shared_ptr<CredentialsProvider> &credentialsProvider,
-    const ClientConfiguration &configuration) : CoreClient(SERVICE_NAME, configuration),
-                                                credentialsProvider_(credentialsProvider),
-                                                signer_(std::make_shared<HmacSha1Signer>())
-{
-}
+    const ClientConfiguration &configuration)
+    : CoreClient(SERVICE_NAME, configuration),
+      credentialsProvider_(credentialsProvider),
+      signer_(std::make_shared<HmacSha1Signer>()) {}
 
 CommonClient::CommonClient(const std::string &accessKeyId,
                            const std::string &accessKeySecret,
-                           const ClientConfiguration &configuration) : CoreClient(SERVICE_NAME, configuration),
-                                                                       credentialsProvider_(std::make_shared<SimpleCredentialsProvider>(accessKeyId,
-                                                                                                                                        accessKeySecret)),
-                                                                       signer_(std::make_shared<HmacSha1Signer>())
-{
-}
+                           const ClientConfiguration &configuration)
+    : CoreClient(SERVICE_NAME, configuration),
+      credentialsProvider_(std::make_shared<SimpleCredentialsProvider>(
+          accessKeyId, accessKeySecret)),
+      signer_(std::make_shared<HmacSha1Signer>()) {}
 
-CommonClient::~CommonClient()
-{
-}
+CommonClient::~CommonClient() {}
 
-CommonClient::JsonOutcome CommonClient::makeRequest(const std::string &endpoint,
-                                                    const CommonRequest &msg, HttpRequest::Method method) const
-{
+CommonClient::JsonOutcome
+CommonClient::makeRequest(const std::string &endpoint, const CommonRequest &msg,
+                          HttpRequest::Method method) const {
   auto outcome = AttemptRequest(endpoint, msg, method);
   if (outcome.isSuccess())
-    return JsonOutcome(std::string(outcome.result().body(),
-                                   outcome.result().bodySize()));
+    return JsonOutcome(
+        std::string(outcome.result().body(), outcome.result().bodySize()));
   else
     return JsonOutcome(outcome.error());
 }
 
-CommonClient::CommonResponseOutcome CommonClient::commonResponse(
-    const CommonRequest &request) const
-{
+CommonClient::CommonResponseOutcome
+CommonClient::commonResponse(const CommonRequest &request) const {
   auto outcome = makeRequest(request.domain(), request, request.httpMethod());
   if (outcome.isSuccess())
     return CommonResponseOutcome(CommonResponse(outcome.result()));
@@ -83,10 +75,9 @@ CommonClient::CommonResponseOutcome CommonClient::commonResponse(
     return CommonResponseOutcome(Error(outcome.error()));
 }
 
-void CommonClient::commonResponseAsync(const CommonRequest &request,
-                                       const CommonResponseAsyncHandler &handler,
-                                       const std::shared_ptr<const AsyncCallerContext> &context) const
-{
+void CommonClient::commonResponseAsync(
+    const CommonRequest &request, const CommonResponseAsyncHandler &handler,
+    const std::shared_ptr<const AsyncCallerContext> &context) const {
   auto fn = [this, request, handler, context]() {
     handler(this, request, commonResponse(request), context);
   };
@@ -95,45 +86,40 @@ void CommonClient::commonResponseAsync(const CommonRequest &request,
 }
 
 CommonClient::CommonResponseOutcomeCallable
-CommonClient::commonResponseCallable(const CommonRequest &request) const
-{
+CommonClient::commonResponseCallable(const CommonRequest &request) const {
   auto task = std::make_shared<std::packaged_task<CommonResponseOutcome()>>(
-      [this, request]() {
-        return this->commonResponse(request);
-      });
+      [this, request]() { return this->commonResponse(request); });
 
   asyncExecute(new Runnable([task]() { (*task)(); }));
   return task->get_future();
 }
 
 HttpRequest CommonClient::buildHttpRequest(const std::string &endpoint,
-                                           const ServiceRequest &msg, HttpRequest::Method method) const
-{
-  return buildHttpRequest(endpoint,
-                          dynamic_cast<const CommonRequest &>(msg), method);
+                                           const ServiceRequest &msg,
+                                           HttpRequest::Method method) const {
+  return buildHttpRequest(endpoint, dynamic_cast<const CommonRequest &>(msg),
+                          method);
 }
 
 HttpRequest CommonClient::buildHttpRequest(const std::string &endpoint,
-                                           const CommonRequest &msg, HttpRequest::Method method) const
-{
+                                           const CommonRequest &msg,
+                                           HttpRequest::Method method) const {
   if (msg.requestPattern() == CommonRequest::RpcPattern)
     return buildRpcHttpRequest(endpoint, msg, method);
   else
     return buildRoaHttpRequest(endpoint, msg, method);
 }
 
-HttpRequest CommonClient::buildRoaHttpRequest(const std::string &endpoint,
-                                              const CommonRequest &msg, HttpRequest::Method method) const
-{
+HttpRequest
+CommonClient::buildRoaHttpRequest(const std::string &endpoint,
+                                  const CommonRequest &msg,
+                                  HttpRequest::Method method) const {
   const Credentials credentials = credentialsProvider_->getCredentials();
 
   Url url;
-  if (msg.scheme().empty())
-  {
+  if (msg.scheme().empty()) {
     url.setScheme("https");
-  }
-  else
-  {
+  } else {
     url.setScheme(msg.scheme());
   }
   url.setHost(endpoint);
@@ -141,17 +127,14 @@ HttpRequest CommonClient::buildRoaHttpRequest(const std::string &endpoint,
 
   auto params = msg.headerParameters();
   std::map<std::string, std::string> queryParams;
-  for (const auto &p : params)
-  {
+  for (const auto &p : params) {
     if (!p.second.empty())
       queryParams[p.first] = p.second;
   }
 
-  if (!queryParams.empty())
-  {
+  if (!queryParams.empty()) {
     std::stringstream queryString;
-    for (const auto &p : queryParams)
-    {
+    for (const auto &p : queryParams) {
       if (p.second.empty())
         queryString << "&" << p.first;
       else
@@ -163,42 +146,30 @@ HttpRequest CommonClient::buildRoaHttpRequest(const std::string &endpoint,
   HttpRequest request(url);
   request.setMethod(method);
 
-  if (msg.connectTimeout() != kInvalidTimeout)
-  {
+  if (msg.connectTimeout() != kInvalidTimeout) {
     request.setConnectTimeout(msg.connectTimeout());
-  }
-  else
-  {
+  } else {
     request.setConnectTimeout(configuration().connectTimeout());
   }
 
-  if (msg.readTimeout() != kInvalidTimeout)
-  {
+  if (msg.readTimeout() != kInvalidTimeout) {
     request.setReadTimeout(msg.readTimeout());
-  }
-  else
-  {
+  } else {
     request.setReadTimeout(configuration().readTimeout());
   }
 
-  if (msg.headerParameter("Accept").empty())
-  {
+  if (msg.headerParameter("Accept").empty()) {
     request.setHeader("Accept", "application/json");
-  }
-  else
-  {
+  } else {
     request.setHeader("Accept", msg.headerParameter("Accept"));
   }
 
   std::stringstream ss;
   ss << msg.contentSize();
   request.setHeader("Content-Length", ss.str());
-  if (msg.headerParameter("Content-Type").empty())
-  {
+  if (msg.headerParameter("Content-Type").empty()) {
     request.setHeader("Content-Type", "application/octet-stream");
-  }
-  else
-  {
+  } else {
     request.setHeader("Content-Type", msg.headerParameter("Content-Type"));
   }
   request.setHeader("Content-MD5",
@@ -239,26 +210,22 @@ HttpRequest CommonClient::buildRoaHttpRequest(const std::string &endpoint,
     plaintext << url.path() << "?" << url.query();
 
   std::stringstream sign;
-  sign << "acs "
-       << credentials.accessKeyId()
-       << ":"
+  sign << "acs " << credentials.accessKeyId() << ":"
        << signer_->generate(plaintext.str(), credentials.accessKeySecret());
   request.setHeader("Authorization", sign.str());
   return request;
 }
 
-HttpRequest CommonClient::buildRpcHttpRequest(const std::string &endpoint,
-                                              const CommonRequest &msg, HttpRequest::Method method) const
-{
+HttpRequest
+CommonClient::buildRpcHttpRequest(const std::string &endpoint,
+                                  const CommonRequest &msg,
+                                  HttpRequest::Method method) const {
   const Credentials credentials = credentialsProvider_->getCredentials();
 
   Url url;
-  if (msg.scheme().empty())
-  {
+  if (msg.scheme().empty()) {
     url.setScheme("https");
-  }
-  else
-  {
+  } else {
     url.setScheme(msg.scheme());
   }
   url.setHost(endpoint);
@@ -266,8 +233,7 @@ HttpRequest CommonClient::buildRpcHttpRequest(const std::string &endpoint,
 
   auto params = msg.queryParameters();
   std::map<std::string, std::string> queryParams;
-  for (const auto &p : params)
-  {
+  for (const auto &p : params) {
     if (!p.second.empty())
       queryParams[p.first] = p.second;
   }
@@ -294,21 +260,17 @@ HttpRequest CommonClient::buildRpcHttpRequest(const std::string &endpoint,
   std::string bodyParamString;
   auto signParams = queryParams;
   auto bodyParams = msg.bodyParameters();
-  for (const auto &p : bodyParams)
-  {
+  for (const auto &p : bodyParams) {
     bodyParamString += "&";
     bodyParamString += (p.first + "=" + UrlEncode(p.second));
     signParams[p.first] = p.second;
   }
 
   std::stringstream plaintext;
-  plaintext << HttpMethodToString(method)
-            << "&"
-            << UrlEncode(url.path())
-            << "&"
+  plaintext << HttpMethodToString(method) << "&" << UrlEncode(url.path()) << "&"
             << UrlEncode(canonicalizedQuery(signParams));
-  queryParams["Signature"] = signer_->generate(plaintext.str(),
-                                               credentials.accessKeySecret() + "&");
+  queryParams["Signature"] =
+      signer_->generate(plaintext.str(), credentials.accessKeySecret() + "&");
 
   std::stringstream queryString;
   for (const auto &p : queryParams)
@@ -316,21 +278,15 @@ HttpRequest CommonClient::buildRpcHttpRequest(const std::string &endpoint,
   url.setQuery(queryString.str().substr(1));
 
   HttpRequest request(url);
-  if (msg.connectTimeout() != kInvalidTimeout)
-  {
+  if (msg.connectTimeout() != kInvalidTimeout) {
     request.setConnectTimeout(msg.connectTimeout());
-  }
-  else
-  {
+  } else {
     request.setConnectTimeout(configuration().connectTimeout());
   }
 
-  if (msg.readTimeout() != kInvalidTimeout)
-  {
+  if (msg.readTimeout() != kInvalidTimeout) {
     request.setReadTimeout(msg.readTimeout());
-  }
-  else
-  {
+  } else {
     request.setReadTimeout(configuration().readTimeout());
   }
 
@@ -339,8 +295,7 @@ HttpRequest CommonClient::buildRpcHttpRequest(const std::string &endpoint,
   request.setHeader("x-sdk-client",
                     std::string("CPP/").append(ALIBABACLOUD_VERSION_STR));
 
-  if (!bodyParamString.empty())
-  {
+  if (!bodyParamString.empty()) {
     request.setBody(bodyParamString.c_str() + 1, bodyParamString.size() - 1);
   }
   return request;

core/src/CommonRequest.cc

@@ -1,41 +1,32 @@
 /*
-* Copyright 1999-2019 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.
-*/
+ * Copyright 1999-2019 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/core/CommonRequest.h>
 
 namespace AlibabaCloud {
 
-CommonRequest::CommonRequest(RequestPattern pattern):
-  ServiceRequest("", ""),
-  domain_(),
-  queryParams_(),
-  httpMethod_(HttpRequest::Get),
-  requestPattern_(pattern) {
-}
+CommonRequest::CommonRequest(RequestPattern pattern)
+    : ServiceRequest("", ""), domain_(), queryParams_(),
+      httpMethod_(HttpRequest::Get), requestPattern_(pattern) {}
 
-CommonRequest::~CommonRequest() {
-}
+CommonRequest::~CommonRequest() {}
 
-std::string CommonRequest::domain()const {
-  return domain_;
-}
+std::string CommonRequest::domain() const { return domain_; }
 
-void CommonRequest::setDomain(const std::string &domain) {
-  domain_ = domain;
-}
+void CommonRequest::setDomain(const std::string &domain) { domain_ = domain; }
 
 CommonRequest::RequestPattern CommonRequest::requestPattern() const {
   return requestPattern_;
@@ -49,12 +40,10 @@ void CommonRequest::setHttpMethod(HttpRequest::Method method) {
   httpMethod_ = method;
 }
 
-HttpRequest::Method CommonRequest::httpMethod() const {
-  return httpMethod_;
-}
+HttpRequest::Method CommonRequest::httpMethod() const { return httpMethod_; }
 
-CommonRequest::ParameterValueType CommonRequest::queryParameter(
-  const ParameterNameType &name) const {
+CommonRequest::ParameterValueType
+CommonRequest::queryParameter(const ParameterNameType &name) const {
   ParameterCollection::const_iterator it = queryParams_.find(name);
   if (it == queryParams_.end()) {
     return ParameterValueType("");
@@ -62,19 +51,18 @@ CommonRequest::ParameterValueType CommonRequest::queryParameter(
   return it->second;
 }
 
-
 CommonRequest::ParameterCollection CommonRequest::queryParameters() const {
   return queryParams_;
 }
 
 void CommonRequest::setQueryParameter(const ParameterNameType &name,
-  const ParameterValueType &value) {
+                                      const ParameterValueType &value) {
   queryParams_[name] = value;
 }
 
-CommonRequest::ParameterValueType CommonRequest::headerParameter(
-  const ParameterNameType &name) const {
-  const ParameterCollection::const_iterator it  = headerParams_.find(name);
+CommonRequest::ParameterValueType
+CommonRequest::headerParameter(const ParameterNameType &name) const {
+  const ParameterCollection::const_iterator it = headerParams_.find(name);
   if (it == headerParams_.end()) {
     return ParameterValueType("");
   }
@@ -86,8 +74,8 @@ CommonRequest::ParameterCollection CommonRequest::headerParameters() const {
 }
 
 void CommonRequest::setHeaderParameter(const ParameterNameType &name,
-  const ParameterValueType &value) {
+                                       const ParameterValueType &value) {
   headerParams_[name] = value;
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/CommonResponse.cc

@@ -1,36 +1,30 @@
 /*
-* Copyright 1999-2019 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.
-*/
+ * Copyright 1999-2019 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/core/CommonResponse.h>
 
 namespace AlibabaCloud {
 
-CommonResponse::CommonResponse() :
-  payload_() {
-}
+CommonResponse::CommonResponse() : payload_() {}
 
-CommonResponse::CommonResponse(const std::string &payload) :
-  payload_(payload) {
-}
+CommonResponse::CommonResponse(const std::string &payload)
+    : payload_(payload) {}
 
-CommonResponse::~CommonResponse() {
-}
+CommonResponse::~CommonResponse() {}
 
-std::string CommonResponse::payload() const {
-  return payload_;
-}
+std::string CommonResponse::payload() const { return payload_; }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/CoreClient.cc

@@ -16,9 +16,9 @@
 
 #include "CurlHttpClient.h"
 #include "Executor.h"
-#include <alibabacloud/core/Utils.h>
 #include <alibabacloud/core/CoreClient.h>
 #include <alibabacloud/core/Signer.h>
+#include <alibabacloud/core/Utils.h>
 #include <json/json.h>
 
 /*!
@@ -33,6 +33,7 @@ CoreClient::CoreClient(const std::string &servicename,
     : serviceName_(servicename), configuration_(configuration),
       httpClient_(new CurlHttpClient) {
   httpClient_->setProxy(configuration.proxy());
+  httpClient_->setRejectUnauthorized(configuration.rejectUnauthorized());
 }
 
 CoreClient::~CoreClient() { delete httpClient_; }
@@ -62,14 +63,10 @@ CoreClient::AttemptRequest(const std::string &endpoint,
 Error CoreClient::buildCoreError(const HttpResponse &response) const {
   Json::Reader reader;
   Json::Value value;
-  if (!reader.parse(std::string(response.body(), response.bodySize()), value))
-  {
-    if (response.bodySize() > 0)
-    {
+  if (!reader.parse(std::string(response.body(), response.bodySize()), value)) {
+    if (response.bodySize() > 0) {
       return Error("InvalidResponse", response.body());
-    }
-    else
-    {
+    } else {
       return Error("InvalidResponse", "body is empty");
     }
   }
@@ -79,8 +76,7 @@ Error CoreClient::buildCoreError(const HttpResponse &response) const {
   error.setErrorMessage(value["Message"].asString());
   error.setHost(value["HostId"].asString());
   error.setRequestId(value["RequestId"].asString());
-  if (value["Code"].asString().empty() || value["Message"].asString().empty())
-  {
+  if (value["Code"].asString().empty() || value["Message"].asString().empty()) {
     error.setDetail(std::string(response.body()));
   }
   return error;

core/src/Credentials.cc

@@ -19,23 +19,16 @@
 namespace AlibabaCloud {
 
 Credentials::Credentials(const std::string &accessKeyId,
-    const std::string &accessKeySecret,
-    const std::string &sessionToken) :
-  accessKeyId_(accessKeyId),
-  accessKeySecret_(accessKeySecret),
-  sessionToken_(sessionToken) {
-}
+                         const std::string &accessKeySecret,
+                         const std::string &sessionToken)
+    : accessKeyId_(accessKeyId), accessKeySecret_(accessKeySecret),
+      sessionToken_(sessionToken) {}
 
-Credentials::~Credentials() {
-}
+Credentials::~Credentials() {}
 
-std::string Credentials::accessKeyId() const {
-  return accessKeyId_;
-}
+std::string Credentials::accessKeyId() const { return accessKeyId_; }
 
-std::string Credentials::accessKeySecret() const {
-  return accessKeySecret_;
-}
+std::string Credentials::accessKeySecret() const { return accessKeySecret_; }
 
 void Credentials::setAccessKeyId(const std::string &accessKeyId) {
   accessKeyId_ = accessKeyId;
@@ -49,8 +42,6 @@ void Credentials::setSessionToken(const std::string &sessionToken) {
   sessionToken_ = sessionToken;
 }
 
-std::string Credentials::sessionToken() const {
-  return sessionToken_;
-}
+std::string Credentials::sessionToken() const { return sessionToken_; }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/CurlHttpClient.cc

@@ -18,9 +18,9 @@
 #include <alibabacloud/core/Utils.h>
 #include <cassert>
 #include <sstream>
+#include <string.h>
 #include <string>
 #include <vector>
-#include <string.h>
 
 namespace AlibabaCloud {
 
@@ -52,13 +52,13 @@ static size_t readCallback(void *ptr, size_t size, size_t nmemb, void *stream) {
 }
 
 size_t recvBody(char *ptr, size_t size, size_t nmemb, void *userdata) {
-  std::ostringstream &out = *static_cast<std::ostringstream*>(userdata);
-  out << std::string(ptr, nmemb*size);
+  std::ostringstream &out = *static_cast<std::ostringstream *>(userdata);
+  out << std::string(ptr, nmemb * size);
   return nmemb * size;
 }
 
 size_t recvHeaders(char *buffer, size_t size, size_t nitems, void *userdata) {
-  HttpResponse *response = static_cast<HttpResponse*>(userdata);
+  HttpResponse *response = static_cast<HttpResponse *>(userdata);
   std::string line(buffer);
   auto pos = line.find(':');
   if (pos != line.npos) {
@@ -98,16 +98,12 @@ void setCUrlProxy(CURL *curlHandle, const NetworkProxy &proxy) {
     curl_easy_setopt(curlHandle, CURLOPT_PROXYUSERPWD, out.str().c_str());
   }
 }
-}  // namespace
+} // namespace
 
-CurlHttpClient::CurlHttpClient() :
-  HttpClient(),
-  curlHandle_(curl_easy_init()) {
-}
+CurlHttpClient::CurlHttpClient()
+    : HttpClient(), curlHandle_(curl_easy_init()) {}
 
-CurlHttpClient::~CurlHttpClient() {
-  curl_easy_cleanup(curlHandle_);
-}
+CurlHttpClient::~CurlHttpClient() { curl_easy_cleanup(curlHandle_); }
 
 HttpClient::HttpResponseOutcome
 CurlHttpClient::makeRequest(const HttpRequest &request) {
@@ -119,52 +115,54 @@ CurlHttpClient::makeRequest(const HttpRequest &request) {
 
   std::string url = request.url().toString();
   switch (request.method()) {
-    case HttpRequest::Method::Get:
+  case HttpRequest::Method::Get:
     break;
-    case HttpRequest::Method::Post: {
-      if (request.bodySize() > 0) {
-        curl_easy_setopt(curlHandle_, CURLOPT_POSTFIELDS, request.body());
-      } else {
-        curl_easy_setopt(curlHandle_, CURLOPT_POSTFIELDS, "");
-      }
+  case HttpRequest::Method::Post: {
+    if (request.bodySize() > 0) {
+      curl_easy_setopt(curlHandle_, CURLOPT_POSTFIELDS, request.body());
+    } else {
+      curl_easy_setopt(curlHandle_, CURLOPT_POSTFIELDS, "");
     }
-    break;
+  } break;
 
-    case HttpRequest::Method::Put: {
-      uploadContext* ctx = (uploadContext *)malloc(sizeof(uploadContext));
-      // this is impossible, as the size is 24 Bytes
-      if (ctx == nullptr) {
-        return HttpResponseOutcome(
+  case HttpRequest::Method::Put: {
+    uploadContext *ctx = (uploadContext *)malloc(sizeof(uploadContext));
+    // this is impossible, as the size is 24 Bytes
+    if (ctx == nullptr) {
+      return HttpResponseOutcome(
           Error("MemoryAllocateError",
-            "There is not enough memory for http transfer."));
-      }
-      ctx->data = request.body();
-      ctx->pos = request.body();
-      ctx->last = ctx->pos + request.bodySize();
-
-      curl_easy_setopt(curlHandle_, CURLOPT_READFUNCTION, readCallback);
-      curl_easy_setopt(curlHandle_, CURLOPT_UPLOAD, 1L);
-      curl_easy_setopt(curlHandle_, CURLOPT_READDATA, ctx);
+                "There is not enough memory for http transfer."));
     }
-    break;
+    ctx->data = request.body();
+    ctx->pos = request.body();
+    ctx->last = ctx->pos + request.bodySize();
 
-    case HttpRequest::Method::Delete: {
-      curl_easy_setopt(curlHandle_, CURLOPT_CUSTOMREQUEST, "DELETE");
-      if (request.bodySize() > 0) {
-        curl_easy_setopt(curlHandle_, CURLOPT_POSTFIELDS, request.body());
-      } else {
-        curl_easy_setopt(curlHandle_, CURLOPT_POSTFIELDS, "");
-      }
+    curl_easy_setopt(curlHandle_, CURLOPT_READFUNCTION, readCallback);
+    curl_easy_setopt(curlHandle_, CURLOPT_UPLOAD, 1L);
+    curl_easy_setopt(curlHandle_, CURLOPT_READDATA, ctx);
+  } break;
+
+  case HttpRequest::Method::Delete: {
+    curl_easy_setopt(curlHandle_, CURLOPT_CUSTOMREQUEST, "DELETE");
+    if (request.bodySize() > 0) {
+      curl_easy_setopt(curlHandle_, CURLOPT_POSTFIELDS, request.body());
+    } else {
+      curl_easy_setopt(curlHandle_, CURLOPT_POSTFIELDS, "");
     }
-    break;
+  } break;
 
-    default:
+  default:
     break;
   }
 
   curl_easy_setopt(curlHandle_, CURLOPT_URL, url.c_str());
-  curl_easy_setopt(curlHandle_, CURLOPT_SSL_VERIFYPEER, 1L);
-  curl_easy_setopt(curlHandle_, CURLOPT_SSL_VERIFYHOST, 2L);
+  if (rejectUnauthorized()) {
+    curl_easy_setopt(curlHandle_, CURLOPT_SSL_VERIFYPEER, 1L);
+    curl_easy_setopt(curlHandle_, CURLOPT_SSL_VERIFYHOST, 2L);
+  } else {
+    curl_easy_setopt(curlHandle_, CURLOPT_SSL_VERIFYPEER, 0L);
+    curl_easy_setopt(curlHandle_, CURLOPT_SSL_VERIFYHOST, 0L);
+  }
   curl_easy_setopt(curlHandle_, CURLOPT_HEADERDATA, &response);
   curl_easy_setopt(curlHandle_, CURLOPT_HEADERFUNCTION, recvHeaders);
 
@@ -195,33 +193,34 @@ CurlHttpClient::makeRequest(const HttpRequest &request) {
 
   CURLcode res = curl_easy_perform(curlHandle_);
   switch (res) {
-    case CURLE_OK: {
-      long response_code;
-      curl_easy_getinfo(curlHandle_, CURLINFO_RESPONSE_CODE, &response_code);
-      response.setStatusCode(response_code);
-      response.setBody(out.str().c_str(), out.str().length());
-      return HttpResponseOutcome(response);
-    }
-    case CURLE_SSL_CONNECT_ERROR:
-      return HttpResponseOutcome(
+  case CURLE_OK: {
+    long response_code;
+    curl_easy_getinfo(curlHandle_, CURLINFO_RESPONSE_CODE, &response_code);
+    response.setStatusCode(response_code);
+    response.setBody(out.str().c_str(), out.str().length());
+    return HttpResponseOutcome(response);
+  }
+  case CURLE_SSL_CONNECT_ERROR:
+    return HttpResponseOutcome(
         Error("SSLConnectError",
-          "A problem occurred somewhere in the SSL/TLS handshake."));
-    case CURLE_OPERATION_TIMEDOUT:
-      return HttpResponseOutcome(
+              "A problem occurred somewhere in the SSL/TLS handshake."));
+  case CURLE_OPERATION_TIMEDOUT:
+    return HttpResponseOutcome(
         Error("OperationTimeoutError",
-          "Timeout (connectTimeout: " +
-          std::to_string(connect_timeout) + "ms, readTimeout: " +
-          std::to_string(read_timeout) + "ms) when connect or read data: " +
-          HttpMethodToString(request.method()) + " " + request.url().toString()));
+              "Timeout (connectTimeout: " + std::to_string(connect_timeout) +
+                  "ms, readTimeout: " + std::to_string(read_timeout) +
+                  "ms) when connect or read data: " +
+                  HttpMethodToString(request.method()) + " " +
+                  request.url().toString()));
 
-    default: {
-      return HttpResponseOutcome(
-        Error("NetworkError",
-          "Failed to connect to host or proxy: " +
-          HttpMethodToString(request.method()) + " " + request.url().toString()));
-    }
+  default: {
+    return HttpResponseOutcome(
+        Error("NetworkError", "Failed to connect to host or proxy: " +
+                                  HttpMethodToString(request.method()) + " " +
+                                  request.url().toString()));
+  }
   }
   curl_slist_free_all(list);
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/CurlHttpClient.h

@@ -22,15 +22,15 @@
 
 namespace AlibabaCloud {
 class CurlHttpClient : public HttpClient {
- public:
+public:
   CurlHttpClient();
   ~CurlHttpClient();
 
   HttpResponseOutcome makeRequest(const HttpRequest &request) override;
 
- private:
+private:
   CURL *curlHandle_;
 };
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud
 
-#endif  // CORE_SRC_CURLHTTPCLIENT_H_
+#endif // CORE_SRC_CURLHTTPCLIENT_H_

core/src/EcsMetadataFetcher.cc

@@ -1,38 +1,34 @@
 /*
-* Copyright 1999-2019 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.
-*/
+ * Copyright 1999-2019 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/core/Url.h>
-#include <sstream>
-#include <memory>
 #include "EcsMetadataFetcher.h"
 #include "CurlHttpClient.h"
+#include <alibabacloud/core/Url.h>
+#include <memory>
+#include <sstream>
 
 namespace AlibabaCloud {
 
-EcsMetadataFetcher::EcsMetadataFetcher() {
-}
+EcsMetadataFetcher::EcsMetadataFetcher() {}
 
-EcsMetadataFetcher::~EcsMetadataFetcher() {
-}
+EcsMetadataFetcher::~EcsMetadataFetcher() {}
 
-std::string EcsMetadataFetcher::roleName()const {
-  return roleName_;
-}
+std::string EcsMetadataFetcher::roleName() const { return roleName_; }
 
-void EcsMetadataFetcher::setRoleName(const std::string & roleName) {
+void EcsMetadataFetcher::setRoleName(const std::string &roleName) {
   roleName_ = roleName;
 }
 
@@ -41,7 +37,7 @@ std::string EcsMetadataFetcher::getMetadata() {
 }
 
 std::string EcsMetadataFetcher::getMetadata(const std::string host,
-  const std::string in_path) {
+                                            const std::string in_path) {
   std::stringstream path;
   path << in_path << roleName_;
 
@@ -61,4 +57,4 @@ std::string EcsMetadataFetcher::getMetadata(const std::string host,
     return outcome.error().errorCode();
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/EcsMetadataFetcher.h

@@ -1,18 +1,18 @@
 /*
-* Copyright 1999-2019 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.
-*/
+ * Copyright 1999-2019 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 CORE_SRC_ECSMETADATAFETCHER_H_
 #define CORE_SRC_ECSMETADATAFETCHER_H_
@@ -20,26 +20,26 @@
 #include <string>
 
 namespace {
-  const int DEFAULT_TIMEOUT_IN_MILLISECONDS = 5000;
-  const char* const METADATA_SERVICE_HOST = "100.100.100.200";
-  const char* const URL_IN_ECS_METADATA =
-  "/latest/meta-data/ram/security-credentials/";
-}
+const int DEFAULT_TIMEOUT_IN_MILLISECONDS = 5000;
+const char *const METADATA_SERVICE_HOST = "100.100.100.200";
+const char *const URL_IN_ECS_METADATA =
+    "/latest/meta-data/ram/security-credentials/";
+} // namespace
 
 namespace AlibabaCloud {
 class EcsMetadataFetcher {
- public:
+public:
   EcsMetadataFetcher();
   ~EcsMetadataFetcher();
 
-  std::string roleName()const;
-  void setRoleName(const std::string & roleName);
+  std::string roleName() const;
+  void setRoleName(const std::string &roleName);
   std::string getMetadata(const std::string host, const std::string path);
   virtual std::string getMetadata();
 
- private:
+private:
   std::string roleName_;
 };
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud
 
-#endif  // CORE_SRC_ECSMETADATAFETCHER_H_
+#endif // CORE_SRC_ECSMETADATAFETCHER_H_

core/src/EndpointProvider.cc

@@ -16,12 +16,12 @@
 
 #include <algorithm>
 #include <alibabacloud/core/EndpointProvider.h>
+#include <condition_variable>
 #include <iomanip>
 #include <json/json.h>
+#include <mutex>
 #include <sstream>
 #include <thread>
-#include <mutex>
-#include <condition_variable>
 
 #ifndef WIN32
 #include "LocalEndpoints.h"
@@ -30,11 +30,9 @@
 #include "LocalEndpointsForWindows.h"
 #endif
 
-namespace AlibabaCloud
-{
+namespace AlibabaCloud {
 
-namespace
-{
+namespace {
 #if defined(WIN32) && defined(_MSC_VER)
 #define strcasecmp _stricmp
 #define strncasecmp _strnicmp
@@ -52,8 +50,7 @@ typedef std::string endpointType;
 typedef std::string mappingType;
 typedef std::vector<regionType> regionsType;
 typedef std::map<productType, endpointType> regionalType;
-typedef struct
-{
+typedef struct {
   regionsType regions;
   regionalType regional;
 } productInfoType;
@@ -62,14 +59,12 @@ static std::vector<regionType> allRegions;
 static std::vector<productType> allProductsInLocalEndpoints;
 static std::map<productType, productInfoType> allLocalEndpoints;
 
-static void LoadLocalEndpoints()
-{
+static void LoadLocalEndpoints() {
   Json::Reader reader;
   Json::Value value;
   std::unique_lock<std::mutex> lock(mutex);
 
-  if (local_endpoints_loaded)
-  {
+  if (local_endpoints_loaded) {
     return;
   }
 
@@ -79,42 +74,38 @@ static void LoadLocalEndpoints()
                                        WIN_LOCAL_ENDPOINTS_CONFIG_3;
 #endif
 
-  if (!reader.parse(LOCAL_ENDPOINTS_CONFIG, value))
-  {
+  if (!reader.parse(LOCAL_ENDPOINTS_CONFIG, value)) {
     return;
   }
 
-  cv.wait(lock, [] { return !local_endpoints_loading; });// continue if loading completed
+  cv.wait(lock, [] {
+    return !local_endpoints_loading;
+  }); // continue if loading completed
 
   local_endpoints_loading = true;
 
   auto regions = value["regions"];
-  for (const auto &region : regions)
-  {
+  for (const auto &region : regions) {
     allRegions.push_back(region.asString());
   }
 
   auto products = value["products"];
-  for (const auto &product : products)
-  {
+  for (const auto &product : products) {
     allProductsInLocalEndpoints.push_back(product.asString());
   }
 
   auto endpoints = value["endpoints"];
-  for (auto &product : allProductsInLocalEndpoints)
-  {
+  for (auto &product : allProductsInLocalEndpoints) {
     auto endpoint_per_product = endpoints[product];
     productInfoType p;
 
     auto regions = endpoint_per_product["regions"];
     auto regional = endpoint_per_product["regional"];
 
-    for (auto &r : regions)
-    {
+    for (auto &r : regions) {
       const std::string region = r.asString();
       p.regions.push_back(region);
-      p.regional[region] =
-          endpoint_per_product["regional"][region].asString();
+      p.regional[region] = endpoint_per_product["regional"][region].asString();
     }
     allLocalEndpoints[product] = p;
   }
@@ -133,8 +124,7 @@ EndpointProvider::EndpointProvider(
     const std::string serviceCode, int durationSeconds)
     : LocationClient(locationClient), regionId_(regionId), product_(product),
       serviceCode_(serviceCode), durationSeconds_(durationSeconds),
-      cachedMutex_(), cachedEndpoint_(), expiry_()
-{
+      cachedMutex_(), cachedEndpoint_(), expiry_() {
   transform(product_.begin(), product_.end(), product_.begin(), ::tolower);
   loadLocalProductsInfo();
 }
@@ -148,34 +138,29 @@ EndpointProvider::EndpointProvider(const Credentials &credentials,
     : LocationClient(credentials, configuration), regionId_(regionId),
       product_(product), serviceCode_(serviceCode),
       durationSeconds_(durationSeconds), cachedMutex_(), cachedEndpoint_(),
-      expiry_()
-{
+      expiry_() {
   transform(product_.begin(), product_.end(), product_.begin(), ::tolower);
   loadLocalProductsInfo();
 }
 
 EndpointProvider::~EndpointProvider() {}
 
-bool EndpointProvider::loadLocalProductsInfo()
-{
+bool EndpointProvider::loadLocalProductsInfo() {
   LoadLocalEndpoints();
   return true;
 }
 
 std::string EndpointProvider::localEndpoint(const std::string regionId,
-                                            const std::string product)
-{
+                                            const std::string product) {
 
-  if (!local_endpoints_loaded)
-  {
+  if (!local_endpoints_loaded) {
     // impossible
     return std::string();
   }
 
   std::vector<regionType>::iterator allRegionsit;
   allRegionsit = std::find(allRegions.begin(), allRegions.end(), regionId);
-  if (allRegionsit == allRegions.end())
-  {
+  if (allRegionsit == allRegions.end()) {
     return std::string();
   }
 
@@ -183,47 +168,40 @@ std::string EndpointProvider::localEndpoint(const std::string regionId,
   allProductsInLocalEndpointsit =
       std::find(allProductsInLocalEndpoints.begin(),
                 allProductsInLocalEndpoints.end(), product);
-  if (allProductsInLocalEndpointsit == allProductsInLocalEndpoints.end())
-  {
+  if (allProductsInLocalEndpointsit == allProductsInLocalEndpoints.end()) {
     return std::string();
   }
 
   std::vector<regionType> vec = allLocalEndpoints[product].regions;
   std::vector<regionType>::iterator it;
   it = std::find(vec.begin(), vec.end(), regionId);
-  if (it == vec.end())
-  {
+  if (it == vec.end()) {
     return std::string();
   }
   return allLocalEndpoints[product].regional[regionId];
 }
 
-bool EndpointProvider::checkExpiry() const
-{
+bool EndpointProvider::checkExpiry() const {
   auto now = std::chrono::system_clock::now();
   auto diff =
       std::chrono::duration_cast<std::chrono::seconds>(now - expiry_).count();
   return (diff > 0 - 60);
 }
 
-EndpointProvider::EndpointOutcome EndpointProvider::getEndpoint()
-{
+EndpointProvider::EndpointOutcome EndpointProvider::getEndpoint() {
   // 1st priority: user specified via configuration
-  if (!configuration().endpoint().empty())
-  {
+  if (!configuration().endpoint().empty()) {
     return EndpointOutcome(configuration().endpoint());
   }
 
   // 2nd priority: local configuration
   std::string endpoint = localEndpoint(regionId_, product_);
-  if (!endpoint.empty())
-  {
+  if (!endpoint.empty()) {
     return EndpointOutcome(endpoint);
   }
 
   // service code is mandatory for location service.
-  if (serviceCode_.empty())
-  {
+  if (serviceCode_.empty()) {
     return EndpointOutcome(
         Error("InvalidRegionId", "Product[" + product_ + "] at region[" +
                                      regionId_ + "] does not exist."));
@@ -231,26 +209,21 @@ EndpointProvider::EndpointOutcome EndpointProvider::getEndpoint()
 
   // 3rd priority: request from location service
   EndpointOutcome outcome = loadRemoteEndpoint();
-  if (outcome.isSuccess())
-  {
+  if (outcome.isSuccess()) {
     return outcome;
   }
 
-  if (outcome.error().errorCode() == "Illegal Parameter")
-  {
+  if (outcome.error().errorCode() == "Illegal Parameter") {
     return EndpointOutcome(Error("InvalidProduct", "Prodcut[" + serviceCode_ +
                                                        "] does not exist."));
   }
   return outcome;
 }
 
-EndpointProvider::EndpointOutcome EndpointProvider::loadRemoteEndpoint()
-{
-  if (checkExpiry())
-  {
+EndpointProvider::EndpointOutcome EndpointProvider::loadRemoteEndpoint() {
+  if (checkExpiry()) {
     std::lock_guard<std::mutex> locker(cachedMutex_);
-    if (checkExpiry())
-    {
+    if (checkExpiry()) {
       Location::Model::DescribeEndpointsRequest request;
       request.setId(regionId_);
       request.setServiceCode(serviceCode_);

core/src/Error.cc

@@ -18,23 +18,18 @@
 
 namespace AlibabaCloud {
 
-Error::Error(std::string code, const std::string message) :
-  errorCode_(code),
-  message_(message),
-  host_(),
-  requestId_(),
-  detail_() {
-}
+Error::Error(std::string code, const std::string message)
+    : errorCode_(code), message_(message), host_(), requestId_(), detail_() {}
 
-std::string Error::errorCode()const { return errorCode_; }
+std::string Error::errorCode() const { return errorCode_; }
 std::string Error::errorMessage() const { return message_; }
 std::string Error::host() const { return host_; }
 std::string Error::requestId() const { return requestId_; }
 std::string Error::detail() const { return detail_; }
 void Error::setErrorCode(const std::string &code) { errorCode_ = code; }
-void Error::setErrorMessage(const std::string& message) { message_ = message; }
-void Error::setHost(const std::string& host) { host_ = host; }
-void Error::setRequestId(const std::string& request) { requestId_ = request; }
-void Error::setDetail(const std::string& detail) { detail_ = detail; }
+void Error::setErrorMessage(const std::string &message) { message_ = message; }
+void Error::setHost(const std::string &host) { host_ = host; }
+void Error::setRequestId(const std::string &request) { requestId_ = request; }
+void Error::setDetail(const std::string &detail) { detail_ = detail; }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/Executor.cc

@@ -1,18 +1,18 @@
 /*
-* Copyright 1999-2019 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.
-*/
+ * Copyright 1999-2019 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 "Executor.h"
 #include <alibabacloud/core/Runnable.h>
@@ -21,12 +21,9 @@ namespace AlibabaCloud {
 
 Executor *Executor::self_ = nullptr;
 
-Executor::Executor() :
-  cvMutex_(),
-  shutdown_(true),
-  tasksQueue_(),
-  tasksQueueMutex_(),
-  thread_() {
+Executor::Executor()
+    : cvMutex_(), shutdown_(true), tasksQueue_(), tasksQueueMutex_(),
+      thread_() {
   self_ = this;
 }
 
@@ -35,9 +32,7 @@ Executor::~Executor() {
   shutdown();
 }
 
-Executor * Executor::instance() {
-  return self_;
-}
+Executor *Executor::instance() { return self_; }
 
 bool Executor::start() {
   if (!isShutdown())
@@ -73,11 +68,9 @@ bool Executor::start() {
   return true;
 }
 
-bool Executor::isShutdown()const {
-  return shutdown_;
-}
+bool Executor::isShutdown() const { return shutdown_; }
 
-void Executor::execute(Runnable* task) {
+void Executor::execute(Runnable *task) {
   if (isShutdown())
     return;
 
@@ -111,4 +104,4 @@ void Executor::shutdown() {
     thread_.join();
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/Executor.h

@@ -1,52 +1,52 @@
 /*
-* Copyright 1999-2019 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.
-*/
+ * Copyright 1999-2019 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 CORE_SRC_EXECUTOR_H_
 #define CORE_SRC_EXECUTOR_H_
 
 #include <atomic>
 #include <condition_variable>
-#include <queue>
-#include <vector>
-#include <thread>
 #include <mutex>
+#include <queue>
+#include <thread>
+#include <vector>
 
 namespace AlibabaCloud {
 class Runnable;
 class Executor {
- public:
+public:
   Executor();
   ~Executor();
 
-  static Executor * instance();
-  void execute(Runnable* task);
-  bool isShutdown()const;
+  static Executor *instance();
+  void execute(Runnable *task);
+  bool isShutdown() const;
   bool start();
   void shutdown();
   void wakeUp();
 
- private:
+private:
   static Executor *self_;
   std::atomic<bool> shutdown_;
-  std::queue<Runnable*> tasksQueue_;
+  std::queue<Runnable *> tasksQueue_;
   std::mutex tasksQueueMutex_;
   std::thread thread_;
   std::condition_variable cv_;
   std::mutex cvMutex_;
 };
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud
 
-#endif  // CORE_SRC_EXECUTOR_H_
+#endif // CORE_SRC_EXECUTOR_H_

core/src/HmacSha1Signer.cc

@@ -16,23 +16,20 @@
 
 #include <alibabacloud/core/HmacSha1Signer.h>
 #ifdef _WIN32
-#include <windows.h>
 #include <wincrypt.h>
+#include <windows.h>
 #else
 #include <openssl/hmac.h>
 #endif
 
 namespace AlibabaCloud {
 
-HmacSha1Signer::HmacSha1Signer() :
-  Signer(HmacSha1, "HMAC-SHA1", "1.0") {
-}
+HmacSha1Signer::HmacSha1Signer() : Signer(HmacSha1, "HMAC-SHA1", "1.0") {}
 
-HmacSha1Signer::~HmacSha1Signer() {
-}
+HmacSha1Signer::~HmacSha1Signer() {}
 
-std::string HmacSha1Signer::generate(const std::string & src,
-  const std::string & secret) const {
+std::string HmacSha1Signer::generate(const std::string &src,
+                                     const std::string &secret) const {
   if (src.empty())
     return std::string();
 
@@ -41,10 +38,10 @@ std::string HmacSha1Signer::generate(const std::string & src,
     BLOBHEADER hdr;
     DWORD dwKeySize;
     BYTE rgbKeyData[];
-  }my_blob;
+  } my_blob;
 
   DWORD kbLen = sizeof(my_blob) + secret.size();
-  my_blob * kb = (my_blob *)LocalAlloc(LPTR, kbLen);
+  my_blob *kb = (my_blob *)LocalAlloc(LPTR, kbLen);
   kb->hdr.bType = PLAINTEXTKEYBLOB;
   kb->hdr.bVersion = CUR_BLOB_VERSION;
   kb->hdr.reserved = 0;
@@ -61,12 +58,12 @@ std::string HmacSha1Signer::generate(const std::string & src,
   ZeroMemory(&HmacInfo, sizeof(HmacInfo));
   HmacInfo.HashAlgid = CALG_SHA1;
 
-  CryptAcquireContext(&hProv, NULL,
-    MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_NEWKEYSET);
-  CryptImportKey(hProv, (BYTE*)kb, kbLen, 0, CRYPT_IPSEC_HMAC_KEY, &hKey);
+  CryptAcquireContext(&hProv, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL,
+                      CRYPT_VERIFYCONTEXT | CRYPT_NEWKEYSET);
+  CryptImportKey(hProv, (BYTE *)kb, kbLen, 0, CRYPT_IPSEC_HMAC_KEY, &hKey);
   CryptCreateHash(hProv, CALG_HMAC, hKey, 0, &hHmacHash);
-  CryptSetHashParam(hHmacHash, HP_HMAC_INFO, (BYTE*)&HmacInfo, 0);
-  CryptHashData(hHmacHash, (BYTE*)(src.c_str()), src.size(), 0);
+  CryptSetHashParam(hHmacHash, HP_HMAC_INFO, (BYTE *)&HmacInfo, 0);
+  CryptHashData(hHmacHash, (BYTE *)(src.c_str()), src.size(), 0);
   CryptGetHashParam(hHmacHash, HP_HASHVAL, pbHash, &dwDataLen, 0);
 
   LocalFree(kb);
@@ -75,11 +72,11 @@ std::string HmacSha1Signer::generate(const std::string & src,
   CryptReleaseContext(hProv, 0);
 
   DWORD dlen = 0;
-  CryptBinaryToString(pbHash,
-    dwDataLen, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, NULL, &dlen);
-  char* dest = new char[dlen];
-  CryptBinaryToString(pbHash,
-    dwDataLen, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, dest, &dlen);
+  CryptBinaryToString(pbHash, dwDataLen,
+                      CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, NULL, &dlen);
+  char *dest = new char[dlen];
+  CryptBinaryToString(pbHash, dwDataLen,
+                      CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, dest, &dlen);
 
   std::string ret = std::string(dest, dlen);
   delete dest;
@@ -89,14 +86,14 @@ std::string HmacSha1Signer::generate(const std::string & src,
   unsigned int mdLen = EVP_MAX_BLOCK_LENGTH;
 
   if (HMAC(EVP_sha1(), secret.c_str(), secret.size(),
-    reinterpret_cast<const unsigned char*>(src.c_str()), src.size(),
-    md, &mdLen) == nullptr)
+           reinterpret_cast<const unsigned char *>(src.c_str()), src.size(), md,
+           &mdLen) == nullptr)
     return std::string();
 
   char encodedData[100];
-  EVP_EncodeBlock(reinterpret_cast<unsigned char*>(encodedData), md, mdLen);
+  EVP_EncodeBlock(reinterpret_cast<unsigned char *>(encodedData), md, mdLen);
   return encodedData;
 #endif
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/HttpClient.cc

@@ -16,24 +16,23 @@
 
 #include <alibabacloud/core/HttpClient.h>
 #include <cassert>
-#include <vector>
 #include <sstream>
+#include <vector>
 
 namespace AlibabaCloud {
 
-HttpClient::HttpClient() :
-  proxy_() {
+HttpClient::HttpClient() : proxy_() {}
+
+HttpClient::~HttpClient() {}
+
+NetworkProxy HttpClient::proxy() const { return proxy_; }
+
+void HttpClient::setProxy(const NetworkProxy &proxy) { proxy_ = proxy; }
+
+bool HttpClient::rejectUnauthorized() const { return rejectUnauthorized_; }
+
+void HttpClient::setRejectUnauthorized(const bool &rejectUnauthorized) {
+  rejectUnauthorized_ = rejectUnauthorized;
 }
 
-HttpClient::~HttpClient() {
-}
-
-NetworkProxy HttpClient::proxy()const {
-  return proxy_;
-}
-
-void HttpClient::setProxy(const NetworkProxy &proxy) {
-  proxy_ = proxy;
-}
-
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/HttpMessage.cc

@@ -14,54 +14,44 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/core/HttpMessage.h>
 #include <algorithm>
+#include <alibabacloud/core/HttpMessage.h>
 
 namespace AlibabaCloud {
 
 namespace {
 #if defined(WIN32) && defined(_MSC_VER)
-#  define strcasecmp _stricmp
-#  define strncasecmp _strnicmp
+#define strcasecmp _stricmp
+#define strncasecmp _strnicmp
 #else
-#  include <strings.h>
+#include <strings.h>
 #endif
 
-  std::string KnownHeaderMapper[] {
-    "Accept",
-    "Accept-Charset",
-    "Accept-Encoding",
-    "Accept-Language",
-    "Authorization",
-    "Connection",
-    "Content-Length",
-    "Content-MD5",
-    "Content-Type",
-    "Date",
-    "Host",
-    "Server",
-    "User-Agent"
-  };
-}  // namespace
+std::string KnownHeaderMapper[]{"Accept",
+                                "Accept-Charset",
+                                "Accept-Encoding",
+                                "Accept-Language",
+                                "Authorization",
+                                "Connection",
+                                "Content-Length",
+                                "Content-MD5",
+                                "Content-Type",
+                                "Date",
+                                "Host",
+                                "Server",
+                                "User-Agent"};
+} // namespace
 
-HttpMessage::HttpMessage() :
-  body_(nullptr),
-  bodySize_(0),
-  headers_() {
-}
+HttpMessage::HttpMessage() : body_(nullptr), bodySize_(0), headers_() {}
 
-HttpMessage::HttpMessage(const HttpMessage &other) :
-  body_(nullptr),
-  bodySize_(other.bodySize_),
-  headers_(other.headers_) {
+HttpMessage::HttpMessage(const HttpMessage &other)
+    : body_(nullptr), bodySize_(other.bodySize_), headers_(other.headers_) {
   setBody(other.body_, other.bodySize_);
 }
 
-HttpMessage::HttpMessage(HttpMessage &&other) {
-  *this = std::move(other);
-}
+HttpMessage::HttpMessage(HttpMessage &&other) { *this = std::move(other); }
 
-HttpMessage& HttpMessage::operator=(const HttpMessage &other) {
+HttpMessage &HttpMessage::operator=(const HttpMessage &other) {
   if (this != &other) {
     body_ = nullptr;
     bodySize_ = 0;
@@ -71,23 +61,23 @@ HttpMessage& HttpMessage::operator=(const HttpMessage &other) {
   return *this;
 }
 
-HttpMessage& HttpMessage::operator=(HttpMessage &&other) {
+HttpMessage &HttpMessage::operator=(HttpMessage &&other) {
   if (this != &other)
     *this = std::move(other);
   return *this;
 }
 
-void HttpMessage::addHeader(const HeaderNameType & name,
-  const HeaderValueType & value) {
+void HttpMessage::addHeader(const HeaderNameType &name,
+                            const HeaderValueType &value) {
   setHeader(name, value);
 }
 
-void HttpMessage::addHeader(KnownHeader header, const HeaderValueType & value) {
+void HttpMessage::addHeader(KnownHeader header, const HeaderValueType &value) {
   setHeader(header, value);
 }
 
-HttpMessage::HeaderValueType HttpMessage::header(
-  const HeaderNameType & name) const {
+HttpMessage::HeaderValueType
+HttpMessage::header(const HeaderNameType &name) const {
   auto it = headers_.find(name);
   if (it != headers_.end())
     return it->second;
@@ -95,11 +85,9 @@ HttpMessage::HeaderValueType HttpMessage::header(
     return std::string();
 }
 
-HttpMessage::HeaderCollection HttpMessage::headers() const {
-  return headers_;
-}
+HttpMessage::HeaderCollection HttpMessage::headers() const { return headers_; }
 
-void HttpMessage::removeHeader(const HeaderNameType & name) {
+void HttpMessage::removeHeader(const HeaderNameType &name) {
   headers_.erase(name);
 }
 
@@ -107,33 +95,24 @@ void HttpMessage::removeHeader(KnownHeader header) {
   removeHeader(KnownHeaderMapper[header]);
 }
 
-void HttpMessage::setHeader(const HeaderNameType & name,
-  const HeaderValueType & value) {
+void HttpMessage::setHeader(const HeaderNameType &name,
+                            const HeaderValueType &value) {
   headers_[name] = value;
 }
 
-void HttpMessage::setHeader(KnownHeader header,
-  const std::string & value) {
+void HttpMessage::setHeader(KnownHeader header, const std::string &value) {
   setHeader(KnownHeaderMapper[header], value);
 }
 
-HttpMessage::~HttpMessage() {
-  setBody(nullptr, 0);
-}
+HttpMessage::~HttpMessage() { setBody(nullptr, 0); }
 
-const char* HttpMessage::body()const {
-  return body_;
-}
+const char *HttpMessage::body() const { return body_; }
 
-size_t HttpMessage::bodySize()const {
-  return bodySize_;
-}
+size_t HttpMessage::bodySize() const { return bodySize_; }
 
-bool HttpMessage::hasBody() const {
-  return (bodySize_ != 0);
-}
+bool HttpMessage::hasBody() const { return (bodySize_ != 0); }
 
-HttpMessage::HeaderValueType HttpMessage::header(KnownHeader header)const {
+HttpMessage::HeaderValueType HttpMessage::header(KnownHeader header) const {
   return this->header(KnownHeaderMapper[header]);
 }
 
@@ -150,9 +129,9 @@ void HttpMessage::setBody(const char *data, size_t size) {
   }
 }
 
-bool HttpMessage::nocaseLess::operator()(const std::string & s1,
-  const std::string & s2) const {
+bool HttpMessage::nocaseLess::operator()(const std::string &s1,
+                                         const std::string &s2) const {
   return strcasecmp(s1.c_str(), s2.c_str()) < 0;
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/HttpRequest.cc

@@ -14,46 +14,29 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/core/HttpRequest.h>
 #include <alibabacloud/core/AlibabaCloud.h>
+#include <alibabacloud/core/HttpRequest.h>
 
 namespace AlibabaCloud {
 
-HttpRequest::HttpRequest(const Url &url, Method method) :
-  HttpMessage(),
-  url_(url),
-  method_(method),
-  connectTimeout_(kDefaultConnectTimeout),
-  readTimeout_(kDefaultReadTimeout) {
-}
+HttpRequest::HttpRequest(const Url &url, Method method)
+    : HttpMessage(), url_(url), method_(method),
+      connectTimeout_(kDefaultConnectTimeout),
+      readTimeout_(kDefaultReadTimeout) {}
 
-HttpRequest::~HttpRequest() {
-}
+HttpRequest::~HttpRequest() {}
 
-HttpRequest::Method HttpRequest::method() const {
-  return method_;
-}
+HttpRequest::Method HttpRequest::method() const { return method_; }
 
+void HttpRequest::setMethod(Method method) { method_ = method; }
 
-void HttpRequest::setMethod(Method method) {
-  method_ = method;
-}
+void HttpRequest::setUrl(const Url &url) { url_ = url; }
 
-void HttpRequest::setUrl(const Url &url) {
-  url_ = url;
-}
+Url HttpRequest::url() const { return url_; }
 
-Url HttpRequest::url()const {
-  return url_;
-}
+long HttpRequest::connectTimeout() const { return connectTimeout_; }
 
-long HttpRequest::connectTimeout() const {
-  return connectTimeout_;
-}
-
-long HttpRequest::readTimeout() const {
-  return readTimeout_;
-}
+long HttpRequest::readTimeout() const { return readTimeout_; }
 
 void HttpRequest::setConnectTimeout(const long connectTimeout) {
   connectTimeout_ = connectTimeout;
@@ -63,4 +46,4 @@ void HttpRequest::setReadTimeout(const long readTimeout) {
   readTimeout_ = readTimeout;
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/HttpResponse.cc

@@ -17,36 +17,23 @@
 #include <alibabacloud/core/HttpResponse.h>
 
 namespace {
-  #define INVALID_STATUS_CODE -1
-}
+#define INVALID_STATUS_CODE -1
+} // namespace
 
 namespace AlibabaCloud {
 
-HttpResponse::HttpResponse() :
-  HttpMessage(),
-  request_(),
-  statusCode_(INVALID_STATUS_CODE) {
-}
+HttpResponse::HttpResponse()
+    : HttpMessage(), request_(), statusCode_(INVALID_STATUS_CODE) {}
 
-HttpResponse::HttpResponse(const HttpRequest & request) :
-  HttpMessage(),
-  request_(request),
-  statusCode_(INVALID_STATUS_CODE) {
-}
+HttpResponse::HttpResponse(const HttpRequest &request)
+    : HttpMessage(), request_(request), statusCode_(INVALID_STATUS_CODE) {}
 
-HttpResponse::~HttpResponse() {
-}
+HttpResponse::~HttpResponse() {}
 
-HttpRequest HttpResponse::request() const {
-  return request_;
-}
+HttpRequest HttpResponse::request() const { return request_; }
 
-void HttpResponse::setStatusCode(int code) {
-  statusCode_ = code;
-}
+void HttpResponse::setStatusCode(int code) { statusCode_ = code; }
 
-int HttpResponse::statusCode() const {
-  return statusCode_;
-}
+int HttpResponse::statusCode() const { return statusCode_; }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/InstanceProfileCredentials.cc

@@ -18,11 +18,9 @@
 
 namespace AlibabaCloud {
 
-InstanceProfileCredentials::InstanceProfileCredentials() :
-  BasicSessionCredentials(Credentials::InstanceProfile) {
-}
+InstanceProfileCredentials::InstanceProfileCredentials()
+    : BasicSessionCredentials(Credentials::InstanceProfile) {}
 
-InstanceProfileCredentials::~InstanceProfileCredentials() {
-}
+InstanceProfileCredentials::~InstanceProfileCredentials() {}
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/InstanceProfileCredentialsProvider.cc

@@ -15,37 +15,33 @@
  */
 
 #include "EcsMetadataFetcher.h"
-#include <alibabacloud/core/Utils.h>
 #include <alibabacloud/core/InstanceProfileCredentialsProvider.h>
+#include <alibabacloud/core/Utils.h>
 #include <chrono>
 #include <iomanip>
 #include <json/json.h>
 #include <mutex>
 #include <sstream>
 
-namespace AlibabaCloud
-{
+namespace AlibabaCloud {
 
 InstanceProfileCredentialsProvider::InstanceProfileCredentialsProvider(
     const std::string &roleName, int durationSeconds)
     : CredentialsProvider(), EcsMetadataFetcher(),
       durationSeconds_(durationSeconds), cachedMutex_(),
-      cachedCredentials_("", ""), expiry_()
-{
+      cachedCredentials_("", ""), expiry_() {
   setRoleName(roleName);
 }
 
 InstanceProfileCredentialsProvider::~InstanceProfileCredentialsProvider() {}
 
-Credentials InstanceProfileCredentialsProvider::getCredentials()
-{
+Credentials InstanceProfileCredentialsProvider::getCredentials() {
   loadCredentials();
   std::lock_guard<std::mutex> locker(cachedMutex_);
   return cachedCredentials_;
 }
 
-bool InstanceProfileCredentialsProvider::checkExpiry() const
-{
+bool InstanceProfileCredentialsProvider::checkExpiry() const {
   auto now = std::chrono::system_clock::now();
   auto diff =
       std::chrono::duration_cast<std::chrono::seconds>(now - expiry_).count();
@@ -53,20 +49,17 @@ bool InstanceProfileCredentialsProvider::checkExpiry() const
   return (diff > 0 - 60);
 }
 
-void InstanceProfileCredentialsProvider::loadCredentials()
-{
-  if (checkExpiry())
-  {
+void InstanceProfileCredentialsProvider::loadCredentials() {
+  if (checkExpiry()) {
     std::lock_guard<std::mutex> locker(cachedMutex_);
-    if (checkExpiry())
-    {
+    if (checkExpiry()) {
       auto outcome = getMetadata();
       Json::Value value;
       Json::Reader reader;
-      if (reader.parse(outcome, value))
-      {
-        if (value["Code"].empty() && value["AccessKeyId"].empty() && value["AccessKeySecret"].empty() && value["SecurityToken"].empty() && value["Expiration"].empty())
-        {
+      if (reader.parse(outcome, value)) {
+        if (value["Code"].empty() && value["AccessKeyId"].empty() &&
+            value["AccessKeySecret"].empty() &&
+            value["SecurityToken"].empty() && value["Expiration"].empty()) {
           cachedCredentials_ = Credentials("", "");
           return;
         }
@@ -77,9 +70,8 @@ void InstanceProfileCredentialsProvider::loadCredentials()
         auto securityToken = value["SecurityToken"].asString();
         auto expiration = value["Expiration"].asString();
 
-        cachedCredentials_ = Credentials(accessKeyId,
-                                         accessKeySecret,
-                                         securityToken);
+        cachedCredentials_ =
+            Credentials(accessKeyId, accessKeySecret, securityToken);
 
         std::tm tm = {};
 #if defined(__GNUG__) && __GNUC__ < 5

core/src/NetworkProxy.cc

@@ -18,32 +18,19 @@
 
 namespace AlibabaCloud {
 
-NetworkProxy::NetworkProxy(Type type,
-    const std::string &hostName,
-    uint16_t port,
-    const std::string &user,
-    const std::string &password)
-: hostName_(hostName),
-  password_(password),
-  port_(port),
-  type_(type),
-  user_(user) {
-}
+NetworkProxy::NetworkProxy(Type type, const std::string &hostName,
+                           uint16_t port, const std::string &user,
+                           const std::string &password)
+    : hostName_(hostName), password_(password), port_(port), type_(type),
+      user_(user) {}
 
-NetworkProxy::~NetworkProxy() {
-}
+NetworkProxy::~NetworkProxy() {}
 
-std::string NetworkProxy::hostName() const {
-  return hostName_;
-}
+std::string NetworkProxy::hostName() const { return hostName_; }
 
-std::string NetworkProxy::password() const {
-  return password_;
-}
+std::string NetworkProxy::password() const { return password_; }
 
-uint16_t NetworkProxy::port() const {
-  return port_;
-}
+uint16_t NetworkProxy::port() const { return port_; }
 
 void NetworkProxy::setHostName(const std::string &hostName) {
   hostName_ = hostName;
@@ -53,24 +40,14 @@ void NetworkProxy::setPassword(const std::string &password) {
   password_ = password;
 }
 
-void NetworkProxy::setPort(uint16_t port) {
-  port_ = port;
-}
+void NetworkProxy::setPort(uint16_t port) { port_ = port; }
 
-void NetworkProxy::setType(NetworkProxy::Type type) {
-  type_ = type;
-}
+void NetworkProxy::setType(NetworkProxy::Type type) { type_ = type; }
 
-void NetworkProxy::setUser(const std::string &user) {
-  user_ = user;
-}
+void NetworkProxy::setUser(const std::string &user) { user_ = user; }
 
-NetworkProxy::Type NetworkProxy::type() const {
-  return type_;
-}
+NetworkProxy::Type NetworkProxy::type() const { return type_; }
 
-std::string NetworkProxy::user() const {
-  return user_;
-}
+std::string NetworkProxy::user() const { return user_; }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/RoaServiceClient.cc

@@ -14,51 +14,53 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/core/AlibabaCloud.h>
-#include <alibabacloud/core/RoaServiceClient.h>
-#include <alibabacloud/core/HmacSha1Signer.h>
 #include <algorithm>
+#include <alibabacloud/core/AlibabaCloud.h>
+#include <alibabacloud/core/HmacSha1Signer.h>
+#include <alibabacloud/core/RoaServiceClient.h>
+#include <alibabacloud/core/Utils.h>
 #include <iomanip>
 #include <sstream>
-#include <alibabacloud/core/Utils.h>
 
 namespace AlibabaCloud {
 
-RoaServiceClient::RoaServiceClient(const std::string & servicename,
-  const std::shared_ptr<CredentialsProvider> &credentialsProvider,
-  const ClientConfiguration &configuration,
-  const std::shared_ptr<Signer> &signer) :
-  CoreClient(servicename, configuration),
-  credentialsProvider_(credentialsProvider),
-  signer_(signer) {
-}
+RoaServiceClient::RoaServiceClient(
+    const std::string &servicename,
+    const std::shared_ptr<CredentialsProvider> &credentialsProvider,
+    const ClientConfiguration &configuration,
+    const std::shared_ptr<Signer> &signer)
+    : CoreClient(servicename, configuration),
+      credentialsProvider_(credentialsProvider), signer_(signer) {}
 
-RoaServiceClient::~RoaServiceClient() {
-}
+RoaServiceClient::~RoaServiceClient() {}
 
-RoaServiceClient::JsonOutcome RoaServiceClient::makeRequest(
-    const std::string &endpoint,
-    const RoaServiceRequest &request, HttpRequest::Method method) const
-{
-  if(method == HttpRequest::Method::Get){
+RoaServiceClient::JsonOutcome
+RoaServiceClient::makeRequest(const std::string &endpoint,
+                              const RoaServiceRequest &request,
+                              HttpRequest::Method method) const {
+  if (method == HttpRequest::Method::Get) {
     method = request.method();
   }
   auto outcome = AttemptRequest(endpoint, request, method);
   if (outcome.isSuccess())
-    return JsonOutcome(std::string(outcome.result().body(),
-      outcome.result().bodySize()));
+    return JsonOutcome(
+        std::string(outcome.result().body(), outcome.result().bodySize()));
   else
     return JsonOutcome(outcome.error());
 }
 
-HttpRequest RoaServiceClient::buildHttpRequest(const std::string & endpoint,
-  const ServiceRequest &msg, HttpRequest::Method method)const {
+HttpRequest
+RoaServiceClient::buildHttpRequest(const std::string &endpoint,
+                                   const ServiceRequest &msg,
+                                   HttpRequest::Method method) const {
   return buildHttpRequest(endpoint,
-    dynamic_cast<const RoaServiceRequest& >(msg), method);
+                          dynamic_cast<const RoaServiceRequest &>(msg), method);
 }
 
-HttpRequest RoaServiceClient::buildHttpRequest(const std::string & endpoint,
-  const RoaServiceRequest &msg, HttpRequest::Method method) const {
+HttpRequest
+RoaServiceClient::buildHttpRequest(const std::string &endpoint,
+                                   const RoaServiceRequest &msg,
+                                   HttpRequest::Method method) const {
   const Credentials credentials = credentialsProvider_->getCredentials();
 
   Url url;
@@ -71,7 +73,7 @@ HttpRequest RoaServiceClient::buildHttpRequest(const std::string & endpoint,
   url.setPath(msg.resourcePath());
 
   auto params = msg.parameters();
-  std::map <std::string, std::string> queryParams;
+  std::map<std::string, std::string> queryParams;
   for (const auto &p : params) {
     if (!p.second.empty())
       queryParams[p.first] = p.second;
@@ -102,10 +104,10 @@ HttpRequest RoaServiceClient::buildHttpRequest(const std::string & endpoint,
     request.setReadTimeout(configuration().readTimeout());
   }
 
-  for(const auto &h : msg.headers()){
-      if(!h.second.empty()){
-          request.setHeader(h.first, h.second);
-      }
+  for (const auto &h : msg.headers()) {
+    if (!h.second.empty()) {
+      request.setHeader(h.first, h.second);
+    }
   }
 
   if (msg.parameter("Accept").empty()) {
@@ -124,7 +126,7 @@ HttpRequest RoaServiceClient::buildHttpRequest(const std::string & endpoint,
       request.setHeader("Content-Type", msg.parameter("Content-Type"));
     }
     request.setHeader("Content-MD5",
-      ComputeContentMD5(msg.content(), msg.contentSize()));
+                      ComputeContentMD5(msg.content(), msg.contentSize()));
     request.setBody(msg.content(), msg.contentSize());
   }
 
@@ -140,7 +142,7 @@ HttpRequest RoaServiceClient::buildHttpRequest(const std::string & endpoint,
   request.setHeader("Date", date.str());
   request.setHeader("Host", url.host());
   request.setHeader("x-sdk-client",
-    std::string("CPP/").append(ALIBABACLOUD_VERSION_STR));
+                    std::string("CPP/").append(ALIBABACLOUD_VERSION_STR));
   request.setHeader("x-acs-region-id", configuration().regionId());
   if (!credentials.sessionToken().empty())
     request.setHeader("x-acs-security-token", credentials.sessionToken());
@@ -151,23 +153,21 @@ HttpRequest RoaServiceClient::buildHttpRequest(const std::string & endpoint,
 
   std::stringstream plaintext;
   plaintext << HttpMethodToString(method) << "\n"
-    << request.header("Accept") << "\n"
-    << request.header("Content-MD5") << "\n"
-    << request.header("Content-Type") << "\n"
-    << request.header("Date") << "\n"
-    << canonicalizedHeaders(request.headers());
+            << request.header("Accept") << "\n"
+            << request.header("Content-MD5") << "\n"
+            << request.header("Content-Type") << "\n"
+            << request.header("Date") << "\n"
+            << canonicalizedHeaders(request.headers());
   if (!url.hasQuery())
     plaintext << url.path();
   else
     plaintext << url.path() << "?" << url.query();
 
   std::stringstream sign;
-  sign << "acs "
-    << credentials.accessKeyId()
-    << ":"
-    << signer_->generate(plaintext.str(), credentials.accessKeySecret());
+  sign << "acs " << credentials.accessKeyId() << ":"
+       << signer_->generate(plaintext.str(), credentials.accessKeySecret());
   request.setHeader("Authorization", sign.str());
   return request;
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/RoaServiceRequest.cc

@@ -14,22 +14,18 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/core/RoaServiceRequest.h>
 #include <algorithm>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/core/Utils.h>
 #include <iomanip>
 #include <sstream>
-#include <alibabacloud/core/Utils.h>
 
-namespace AlibabaCloud
-{
+namespace AlibabaCloud {
 
 RoaServiceRequest::RoaServiceRequest(const std::string &product,
-                                     const std::string &version) : ServiceRequest(product, version)
-{
-}
+                                     const std::string &version)
+    : ServiceRequest(product, version) {}
 
-RoaServiceRequest::~RoaServiceRequest()
-{
-}
+RoaServiceRequest::~RoaServiceRequest() {}
 
 } // namespace AlibabaCloud

core/src/RpcServiceClient.cc

@@ -14,61 +14,59 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/core/AlibabaCloud.h>
-#include <alibabacloud/core/RpcServiceClient.h>
-#include <alibabacloud/core/HmacSha1Signer.h>
 #include <algorithm>
+#include <alibabacloud/core/AlibabaCloud.h>
+#include <alibabacloud/core/HmacSha1Signer.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include <alibabacloud/core/Utils.h>
 #include <iomanip>
 #include <sstream>
-#include <alibabacloud/core/Utils.h>
 
 namespace AlibabaCloud {
 
-RpcServiceClient::RpcServiceClient(const std::string & servicename,
-  const std::shared_ptr<CredentialsProvider> &credentialsProvider,
-  const ClientConfiguration &configuration,
-  const std::shared_ptr<Signer> &signer) :
-  CoreClient(servicename, configuration),
-  credentialsProvider_(credentialsProvider),
-  signer_(signer) {
-}
+RpcServiceClient::RpcServiceClient(
+    const std::string &servicename,
+    const std::shared_ptr<CredentialsProvider> &credentialsProvider,
+    const ClientConfiguration &configuration,
+    const std::shared_ptr<Signer> &signer)
+    : CoreClient(servicename, configuration),
+      credentialsProvider_(credentialsProvider), signer_(signer) {}
 
-RpcServiceClient::~RpcServiceClient() {
-}
+RpcServiceClient::~RpcServiceClient() {}
 
-RpcServiceClient::JsonOutcome RpcServiceClient::makeRequest(
-    const std::string &endpoint,
-    const RpcServiceRequest &request, HttpRequest::Method method) const
-{
-  if (method == HttpRequest::Method::Get)
-  {
+RpcServiceClient::JsonOutcome
+RpcServiceClient::makeRequest(const std::string &endpoint,
+                              const RpcServiceRequest &request,
+                              HttpRequest::Method method) const {
+  if (method == HttpRequest::Method::Get) {
     method = request.method();
   }
   auto outcome = AttemptRequest(endpoint, request, method);
   if (outcome.isSuccess())
-    return JsonOutcome(std::string(outcome.result().body(),
-      outcome.result().bodySize()));
+    return JsonOutcome(
+        std::string(outcome.result().body(), outcome.result().bodySize()));
   else
     return JsonOutcome(outcome.error());
 }
 
-HttpRequest RpcServiceClient::buildHttpRequest(const std::string & endpoint,
-  const ServiceRequest &msg, HttpRequest::Method method)const {
+HttpRequest
+RpcServiceClient::buildHttpRequest(const std::string &endpoint,
+                                   const ServiceRequest &msg,
+                                   HttpRequest::Method method) const {
   return buildHttpRequest(endpoint,
-    dynamic_cast<const RpcServiceRequest& >(msg), method);
+                          dynamic_cast<const RpcServiceRequest &>(msg), method);
 }
 
-HttpRequest RpcServiceClient::buildHttpRequest(const std::string & endpoint,
-  const RpcServiceRequest &msg, HttpRequest::Method method) const {
+HttpRequest
+RpcServiceClient::buildHttpRequest(const std::string &endpoint,
+                                   const RpcServiceRequest &msg,
+                                   HttpRequest::Method method) const {
   const Credentials credentials = credentialsProvider_->getCredentials();
 
   Url url;
-  if (msg.scheme().empty())
-  {
+  if (msg.scheme().empty()) {
     url.setScheme("https");
-  }
-  else
-  {
+  } else {
     url.setScheme(msg.scheme());
   }
   url.setHost(endpoint);
@@ -77,8 +75,7 @@ HttpRequest RpcServiceClient::buildHttpRequest(const std::string & endpoint,
   std::map<std::string, std::string> signParams;
 
   auto params = msg.parameters();
-  for (const auto &p : params)
-  {
+  for (const auto &p : params) {
     if (!p.second.empty())
       signParams[p.first] = p.second;
   }
@@ -103,25 +100,20 @@ HttpRequest RpcServiceClient::buildHttpRequest(const std::string & endpoint,
   signParams["Version"] = msg.version();
 
   std::map<std::string, std::string> query;
-  for (const auto &p : signParams)
-  {
+  for (const auto &p : signParams) {
     query[p.first] = p.second;
   }
 
   auto body_params = msg.bodyParameters();
-  for (const auto &p : body_params)
-  {
+  for (const auto &p : body_params) {
     signParams[p.first] = p.second;
   }
 
   std::stringstream plaintext;
-  plaintext << HttpMethodToString(method)
-            << "&"
-            << UrlEncode(url.path())
-            << "&"
+  plaintext << HttpMethodToString(method) << "&" << UrlEncode(url.path()) << "&"
             << UrlEncode(canonicalizedQuery(signParams));
-  query["Signature"] = signer_->generate(plaintext.str(),
-                                         credentials.accessKeySecret() + "&");
+  query["Signature"] =
+      signer_->generate(plaintext.str(), credentials.accessKeySecret() + "&");
 
   std::stringstream queryString;
   for (const auto &p : query)
@@ -129,29 +121,21 @@ HttpRequest RpcServiceClient::buildHttpRequest(const std::string & endpoint,
   url.setQuery(queryString.str().substr(1));
 
   HttpRequest request(url);
-  if (msg.connectTimeout() != kInvalidTimeout)
-  {
+  if (msg.connectTimeout() != kInvalidTimeout) {
     request.setConnectTimeout(msg.connectTimeout());
-  }
-  else
-  {
+  } else {
     request.setConnectTimeout(configuration().connectTimeout());
   }
 
-  for (const auto &h : msg.headers())
-  {
-    if (!h.second.empty())
-    {
+  for (const auto &h : msg.headers()) {
+    if (!h.second.empty()) {
       request.setHeader(h.first, h.second);
     }
   }
 
-  if (msg.readTimeout() != kInvalidTimeout)
-  {
+  if (msg.readTimeout() != kInvalidTimeout) {
     request.setReadTimeout(msg.readTimeout());
-  }
-  else
-  {
+  } else {
     request.setReadTimeout(configuration().readTimeout());
   }
 
@@ -162,11 +146,11 @@ HttpRequest RpcServiceClient::buildHttpRequest(const std::string & endpoint,
   std::stringstream tmp;
   for (const auto &p : body_params)
     tmp << "&" << p.first << "=" << UrlEncode(p.second);
-  if(tmp.str().length() > 0){
+  if (tmp.str().length() > 0) {
     std::string body = tmp.str().substr(1);
     request.setBody(body.c_str(), body.length());
   }
   return request;
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/RpcServiceRequest.cc

@@ -18,21 +18,21 @@
 
 namespace AlibabaCloud {
 
-RpcServiceRequest::RpcServiceRequest(const std::string & product,
-  const std::string & version, const std::string & action) :
-  ServiceRequest(product, version) {
+RpcServiceRequest::RpcServiceRequest(const std::string &product,
+                                     const std::string &version,
+                                     const std::string &action)
+    : ServiceRequest(product, version) {
   setActionName(action);
 }
 
-RpcServiceRequest::~RpcServiceRequest() {
-}
+RpcServiceRequest::~RpcServiceRequest() {}
 
-std::string RpcServiceRequest::actionName()const {
+std::string RpcServiceRequest::actionName() const {
   return parameter("Action");
 }
 
-void RpcServiceRequest::setActionName(const std::string & name) {
+void RpcServiceRequest::setActionName(const std::string &name) {
   setParameter("Action", name);
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/Runnable.cc

@@ -1,29 +1,25 @@
 /*
-* Copyright 1999-2019 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.
-*/
+ * Copyright 1999-2019 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/core/Runnable.h>
 
 namespace AlibabaCloud {
 
-Runnable::Runnable(const std::function<void()> f) :
-  f_(f) {
-}
+Runnable::Runnable(const std::function<void()> f) : f_(f) {}
 
-void Runnable::run() const {
-  f_();
-}
+void Runnable::run() const { f_(); }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/ServiceRequest.cc

@@ -14,49 +14,34 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/core/ServiceRequest.h>
 #include <alibabacloud/core/AlibabaCloud.h>
+#include <alibabacloud/core/ServiceRequest.h>
 #include <alibabacloud/core/Utils.h>
 
-namespace AlibabaCloud
-{
+namespace AlibabaCloud {
 
 ServiceRequest::ServiceRequest(const std::string &product,
-                               const std::string &version) : content_(nullptr),
-                                                             contentSize_(0),
-                                                             params_(),
-                                                             product_(product),
-                                                             resourcePath_("/"),
-                                                             version_(version),
-                                                             scheme_("https"),
-                                                             connectTimeout_(kInvalidTimeout),
-                                                             readTimeout_(kInvalidTimeout),
-                                                             method_(HttpRequest::Method::Get)
-{
-}
+                               const std::string &version)
+    : content_(nullptr), contentSize_(0), params_(), product_(product),
+      resourcePath_("/"), version_(version), scheme_("https"),
+      connectTimeout_(kInvalidTimeout), readTimeout_(kInvalidTimeout),
+      method_(HttpRequest::Method::Get) {}
 
-ServiceRequest::ServiceRequest(const ServiceRequest &other) : content_(nullptr),
-                                                              contentSize_(other.contentSize_),
-                                                              params_(other.params_),
-                                                              product_(other.product_),
-                                                              resourcePath_(other.resourcePath_),
-                                                              version_(other.version_),
-                                                              scheme_(other.scheme_),
-                                                              connectTimeout_(other.connectTimeout_),
-                                                              readTimeout_(other.readTimeout_)
-{
+ServiceRequest::ServiceRequest(const ServiceRequest &other)
+    : content_(nullptr), contentSize_(other.contentSize_),
+      params_(other.params_), product_(other.product_),
+      resourcePath_(other.resourcePath_), version_(other.version_),
+      scheme_(other.scheme_), connectTimeout_(other.connectTimeout_),
+      readTimeout_(other.readTimeout_) {
   setContent(other.content_, other.contentSize_);
 }
 
-ServiceRequest::ServiceRequest(ServiceRequest &&other)
-{
+ServiceRequest::ServiceRequest(ServiceRequest &&other) {
   *this = std::move(other);
 }
 
-ServiceRequest &ServiceRequest::operator=(const ServiceRequest &other)
-{
-  if (this != &other)
-  {
+ServiceRequest &ServiceRequest::operator=(const ServiceRequest &other) {
+  if (this != &other) {
     content_ = nullptr;
     contentSize_ = 0;
     params_ = other.params_;
@@ -67,42 +52,29 @@ ServiceRequest &ServiceRequest::operator=(const ServiceRequest &other)
   return *this;
 }
 
-ServiceRequest &ServiceRequest::operator=(ServiceRequest &&other)
-{
+ServiceRequest &ServiceRequest::operator=(ServiceRequest &&other) {
   if (this != &other)
     *this = std::move(other);
   return *this;
 }
 
-ServiceRequest::~ServiceRequest()
-{
+ServiceRequest::~ServiceRequest() {
   if (content_)
     delete content_;
 }
 
-const char *ServiceRequest::content() const
-{
-  return content_;
-}
+const char *ServiceRequest::content() const { return content_; }
 
-size_t ServiceRequest::contentSize() const
-{
-  return contentSize_;
-}
+size_t ServiceRequest::contentSize() const { return contentSize_; }
 
-bool ServiceRequest::hasContent() const
-{
-  return (contentSize_ != 0);
-}
+bool ServiceRequest::hasContent() const { return (contentSize_ != 0); }
 
-void ServiceRequest::setContent(const char *data, size_t size)
-{
+void ServiceRequest::setContent(const char *data, size_t size) {
   if (content_)
     delete content_;
   content_ = nullptr;
   contentSize_ = 0;
-  if (size)
-  {
+  if (size) {
     contentSize_ = size;
     content_ = new char[size];
     std::copy(data, data + size, content_);
@@ -110,160 +82,119 @@ void ServiceRequest::setContent(const char *data, size_t size)
 }
 
 void ServiceRequest::addParameter(const ParameterNameType &name,
-                                  const ParameterValueType &value)
-{
+                                  const ParameterValueType &value) {
   setParameter(name, value);
 }
 
-ServiceRequest::ParameterValueType ServiceRequest::parameter(
-    const ParameterNameType &name) const
-{
+ServiceRequest::ParameterValueType
+ServiceRequest::parameter(const ParameterNameType &name) const {
   ParameterCollection::const_iterator it = params_.find(name);
-  if (it == params_.end())
-  {
+  if (it == params_.end()) {
     return ParameterValueType("");
   }
   return it->second;
 }
 
-ServiceRequest::ParameterValueType ServiceRequest::coreParameter(
-    const ParameterNameType &name) const
-{
+ServiceRequest::ParameterValueType
+ServiceRequest::coreParameter(const ParameterNameType &name) const {
   return parameter(name);
 }
 
-ServiceRequest::ParameterCollection ServiceRequest::parameters() const
-{
+ServiceRequest::ParameterCollection ServiceRequest::parameters() const {
   return params_;
 }
 
-
-ServiceRequest::ParameterCollection ServiceRequest::bodyParameters() const
-{
+ServiceRequest::ParameterCollection ServiceRequest::bodyParameters() const {
   return body_params_;
 }
 
-void ServiceRequest::removeParameter(const ParameterNameType &name)
-{
+void ServiceRequest::removeParameter(const ParameterNameType &name) {
   params_.erase(name);
 }
 
 void ServiceRequest::setParameter(const ParameterNameType &name,
-                                  const ParameterValueType &value)
-{
+                                  const ParameterValueType &value) {
   params_[name] = value;
 }
 
-void ServiceRequest::setCoreParameter(const ParameterNameType &name, const ParameterValueType &value)
-{
+void ServiceRequest::setCoreParameter(const ParameterNameType &name,
+                                      const ParameterValueType &value) {
   setParameter(name, value);
 }
 
-void ServiceRequest::setBodyParameter(const ParameterNameType &name, const ParameterValueType &value)
-{
+void ServiceRequest::setBodyParameter(const ParameterNameType &name,
+                                      const ParameterValueType &value) {
   body_params_[name] = value;
 }
 
-void ServiceRequest::setParameters(const ParameterCollection &params)
-{
+void ServiceRequest::setParameters(const ParameterCollection &params) {
   params_ = params;
 }
 
-void ServiceRequest::setJsonParameters(const ParameterNameType &name, const ParameterCollection &params)
-{
+void ServiceRequest::setJsonParameters(const ParameterNameType &name,
+                                       const ParameterCollection &params) {
   params_ = params;
   params_ = params;
   setParameter(name, AlibabaCloud::MapToJson(params));
 }
 
-std::string ServiceRequest::version() const
-{
-  return version_;
-}
+std::string ServiceRequest::version() const { return version_; }
 
-HttpRequest::Method ServiceRequest::method() const
-{
-  return method_;
-}
+HttpRequest::Method ServiceRequest::method() const { return method_; }
 
-void ServiceRequest::setVersion(const std::string &version)
-{
+void ServiceRequest::setVersion(const std::string &version) {
   version_ = version;
 }
 
-std::string ServiceRequest::product() const
-{
-  return product_;
-}
+std::string ServiceRequest::product() const { return product_; }
 
-void ServiceRequest::setProduct(const std::string &product)
-{
+void ServiceRequest::setProduct(const std::string &product) {
   product_ = product;
 }
 
-std::string ServiceRequest::resourcePath() const
-{
-  return resourcePath_;
-}
+std::string ServiceRequest::resourcePath() const { return resourcePath_; }
 
-void ServiceRequest::setResourcePath(const std::string &path)
-{
+void ServiceRequest::setResourcePath(const std::string &path) {
   resourcePath_ = path;
 }
 
-void ServiceRequest::setScheme(const std::string scheme)
-{
-  scheme_ = scheme;
-}
+void ServiceRequest::setScheme(const std::string scheme) { scheme_ = scheme; }
 
-std::string ServiceRequest::scheme() const
-{
-  return scheme_;
-}
+std::string ServiceRequest::scheme() const { return scheme_; }
 
-long ServiceRequest::connectTimeout() const
-{
-  return connectTimeout_;
-}
+long ServiceRequest::connectTimeout() const { return connectTimeout_; }
 
-long ServiceRequest::readTimeout() const
-{
-  return readTimeout_;
-}
+long ServiceRequest::readTimeout() const { return readTimeout_; }
 
-void ServiceRequest::setConnectTimeout(const long connectTimeout)
-{
+void ServiceRequest::setConnectTimeout(const long connectTimeout) {
   connectTimeout_ = connectTimeout;
 }
 
-void ServiceRequest::setReadTimeout(const long readTimeout)
-{
+void ServiceRequest::setReadTimeout(const long readTimeout) {
   readTimeout_ = readTimeout;
 }
 
-void ServiceRequest::setMethod(const HttpRequest::Method method)
-{
+void ServiceRequest::setMethod(const HttpRequest::Method method) {
   method_ = method;
 }
 
-void ServiceRequest::setHeader(const ServiceRequest::ParameterNameType &name,
-                               const ServiceRequest::ParameterValueType &value)
-{
+void ServiceRequest::setHeader(
+    const ServiceRequest::ParameterNameType &name,
+    const ServiceRequest::ParameterValueType &value) {
   headers_[name] = value;
 }
 
-ServiceRequest::ParameterValueType ServiceRequest::getHeader(const ServiceRequest::ParameterNameType &name)
-{
+ServiceRequest::ParameterValueType
+ServiceRequest::getHeader(const ServiceRequest::ParameterNameType &name) {
   return headers_[name];
 }
 
-void ServiceRequest::removeHeader(const ServiceRequest::ParameterNameType &name)
-{
+void ServiceRequest::removeHeader(
+    const ServiceRequest::ParameterNameType &name) {
   headers_.erase(name);
 }
 
-ServiceRequest::ParameterCollection ServiceRequest::headers() const
-{
+ServiceRequest::ParameterCollection ServiceRequest::headers() const {
   return headers_;
 }
 

core/src/ServiceResult.cc

@@ -18,19 +18,14 @@
 
 namespace AlibabaCloud {
 
-ServiceResult::ServiceResult() :
-  requestId_() {
-}
+ServiceResult::ServiceResult() : requestId_() {}
 
-ServiceResult::~ServiceResult() {
-}
+ServiceResult::~ServiceResult() {}
 
-std::string ServiceResult::requestId() const {
-  return requestId_;
-}
+std::string ServiceResult::requestId() const { return requestId_; }
 
-void ServiceResult::setRequestId(const std::string & requestId) {
+void ServiceResult::setRequestId(const std::string &requestId) {
   requestId_ = requestId;
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/Signer.cc

@@ -18,26 +18,15 @@
 
 namespace AlibabaCloud {
 
-Signer::Signer(Type type, const std::string & name,
-  const std::string & version) :
-  type_(type),
-  name_(name),
-  version_(version) {
-}
+Signer::Signer(Type type, const std::string &name, const std::string &version)
+    : type_(type), name_(name), version_(version) {}
 
-Signer::~Signer() {
-}
+Signer::~Signer() {}
 
-std::string Signer::name() const {
-  return name_;
-}
+std::string Signer::name() const { return name_; }
 
-Signer::Type Signer::type() const {
-  return type_;
-}
+Signer::Type Signer::type() const { return type_; }
 
-std::string Signer::version() const {
-  return version_;
-}
+std::string Signer::version() const { return version_; }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/SimpleCredentialsProvider.cc

@@ -19,22 +19,15 @@
 namespace AlibabaCloud {
 
 SimpleCredentialsProvider::SimpleCredentialsProvider(
-  const Credentials &credentials):
-  CredentialsProvider(),
-  credentials_(credentials) {
-}
+    const Credentials &credentials)
+    : CredentialsProvider(), credentials_(credentials) {}
 
 SimpleCredentialsProvider::SimpleCredentialsProvider(
-  const std::string & accessKeyId, const std::string & accessKeySecret) :
-  CredentialsProvider(),
-  credentials_(accessKeyId, accessKeySecret) {
-}
+    const std::string &accessKeyId, const std::string &accessKeySecret)
+    : CredentialsProvider(), credentials_(accessKeyId, accessKeySecret) {}
 
-SimpleCredentialsProvider::~SimpleCredentialsProvider() {
-}
+SimpleCredentialsProvider::~SimpleCredentialsProvider() {}
 
-Credentials SimpleCredentialsProvider::getCredentials() {
-  return credentials_;
-}
+Credentials SimpleCredentialsProvider::getCredentials() { return credentials_; }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/StsAssumeRoleCredentialsProvider.cc

@@ -1,18 +1,18 @@
 /*
-* Copyright 1999-2019 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.
-*/
+ * Copyright 1999-2019 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/core/StsAssumeRoleCredentialsProvider.h>
 #include <iomanip>
@@ -21,25 +21,15 @@
 namespace AlibabaCloud {
 
 StsAssumeRoleCredentialsProvider::StsAssumeRoleCredentialsProvider(
-    const Credentials &credentials,
-    const ClientConfiguration &configuration,
-    const std::string & roleArn,
-    const std::string & roleSessionName,
-    const std::string & policy,
-    int durationSeconds):
-  CredentialsProvider(),
-  StsClient(credentials, configuration),
-  roleArn_(roleArn),
-  roleSessionName_(roleSessionName),
-  policy_(policy),
-  durationSeconds_(durationSeconds),
-  cachedMutex_(),
-  cachedCredentials_("", ""),
-  expiry_() {
-}
+    const Credentials &credentials, const ClientConfiguration &configuration,
+    const std::string &roleArn, const std::string &roleSessionName,
+    const std::string &policy, int durationSeconds)
+    : CredentialsProvider(), StsClient(credentials, configuration),
+      roleArn_(roleArn), roleSessionName_(roleSessionName), policy_(policy),
+      durationSeconds_(durationSeconds), cachedMutex_(),
+      cachedCredentials_("", ""), expiry_() {}
 
-StsAssumeRoleCredentialsProvider::~StsAssumeRoleCredentialsProvider() {
-}
+StsAssumeRoleCredentialsProvider::~StsAssumeRoleCredentialsProvider() {}
 
 Credentials StsAssumeRoleCredentialsProvider::getCredentials() {
   loadCredentials();
@@ -47,10 +37,10 @@ Credentials StsAssumeRoleCredentialsProvider::getCredentials() {
   return cachedCredentials_;
 }
 
-bool StsAssumeRoleCredentialsProvider::checkExpiry()const {
+bool StsAssumeRoleCredentialsProvider::checkExpiry() const {
   auto now = std::chrono::system_clock::now();
   auto diff =
-  std::chrono::duration_cast<std::chrono::seconds>(now - expiry_).count();
+      std::chrono::duration_cast<std::chrono::seconds>(now - expiry_).count();
 
   return (diff > 0 - 60);
 }
@@ -69,8 +59,8 @@ void StsAssumeRoleCredentialsProvider::loadCredentials() {
       if (assumeRoleOutcome.isSuccess()) {
         const auto stsCredentials = assumeRoleOutcome.result().credentials();
         cachedCredentials_ = Credentials(stsCredentials.accessKeyId,
-          stsCredentials.accessKeySecret,
-          stsCredentials.securityToken);
+                                         stsCredentials.accessKeySecret,
+                                         stsCredentials.securityToken);
 
         std::tm tm = {};
 #if defined(__GNUG__) && __GNUC__ < 5
@@ -85,4 +75,4 @@ void StsAssumeRoleCredentialsProvider::loadCredentials() {
   }
 }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/Url.cc

@@ -14,46 +14,33 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/core/Url.h>
 #include <algorithm>
+#include <alibabacloud/core/Url.h>
 #include <sstream>
 
 namespace AlibabaCloud {
 
 namespace {
 #define INVALID_PORT -1
-}
+} // namespace
 
-Url::Url(const std::string & url) :
-  scheme_(),
-  userName_(),
-  password_(),
-  host_(),
-  path_(),
-  port_(INVALID_PORT),
-  query_(),
-  fragment_() {
+Url::Url(const std::string &url)
+    : scheme_(), userName_(), password_(), host_(), path_(),
+      port_(INVALID_PORT), query_(), fragment_() {
   if (!url.empty())
     fromString(url);
 }
 
-Url::~Url() {
-}
+Url::~Url() {}
 
 bool Url::operator==(const Url &url) const {
-  return scheme_ == url.scheme_
-    && userName_ == url.userName_
-    && password_ == url.password_
-    && host_ == url.host_
-    && path_ == url.path_
-    && port_ == url.port_
-    && query_ == url.query_
-    && fragment_ == url.fragment_;
+  return scheme_ == url.scheme_ && userName_ == url.userName_ &&
+         password_ == url.password_ && host_ == url.host_ &&
+         path_ == url.path_ && port_ == url.port_ && query_ == url.query_ &&
+         fragment_ == url.fragment_;
 }
 
-bool Url::operator!=(const Url &url) const {
-  return !(*this == url);
-}
+bool Url::operator!=(const Url &url) const { return !(*this == url); }
 
 std::string Url::authority() const {
   if (!isValid())
@@ -80,11 +67,9 @@ void Url::clear() {
   fragment_.clear();
 }
 
-std::string Url::fragment() const {
-  return fragment_;
-}
+std::string Url::fragment() const { return fragment_; }
 
-void Url::fromString(const std::string & url) {
+void Url::fromString(const std::string &url) {
   clear();
   if (url.empty())
     return;
@@ -128,27 +113,16 @@ void Url::fromString(const std::string & url) {
   setFragment(fragment);
 }
 
-bool Url::hasFragment() const {
-  return !fragment_.empty();
-}
+bool Url::hasFragment() const { return !fragment_.empty(); }
 
-bool Url::hasQuery() const {
-  return !query_.empty();
-}
+bool Url::hasQuery() const { return !query_.empty(); }
 
-std::string Url::host() const {
-  return host_;
-}
+std::string Url::host() const { return host_; }
 
 bool Url::isEmpty() const {
-  return scheme_.empty()
-    && userName_.empty()
-    && password_.empty()
-    && host_.empty()
-    && path_.empty()
-    && (port_ == INVALID_PORT)
-    && query_.empty()
-    && fragment_.empty();
+  return scheme_.empty() && userName_.empty() && password_.empty() &&
+         host_.empty() && path_.empty() && (port_ == INVALID_PORT) &&
+         query_.empty() && fragment_.empty();
 }
 
 bool Url::isValid() const {
@@ -164,27 +138,17 @@ bool Url::isValid() const {
   return valid;
 }
 
-int Url::port() const {
-  return port_;
-}
+int Url::port() const { return port_; }
 
-std::string Url::password() const {
-  return password_;
-}
+std::string Url::password() const { return password_; }
 
-std::string Url::path() const {
-  return path_;
-}
+std::string Url::path() const { return path_; }
 
-std::string Url::query() const {
-  return query_;
-}
+std::string Url::query() const { return query_; }
 
-std::string Url::scheme() const {
-  return scheme_;
-}
+std::string Url::scheme() const { return scheme_; }
 
-void Url::setAuthority(const std::string & authority) {
+void Url::setAuthority(const std::string &authority) {
   if (authority.empty()) {
     setUserInfo("");
     setHost("");
@@ -213,14 +177,12 @@ void Url::setAuthority(const std::string & authority) {
 
   setUserInfo(userinfo);
   setHost(host);
-  setPort(!port.empty() ? atoi(port.c_str()): INVALID_PORT);
+  setPort(!port.empty() ? atoi(port.c_str()) : INVALID_PORT);
 }
 
-void Url::setFragment(const std::string & fragment) {
-  fragment_ = fragment;
-}
+void Url::setFragment(const std::string &fragment) { fragment_ = fragment; }
 
-void Url::setHost(const std::string & host) {
+void Url::setHost(const std::string &host) {
   if (host.empty()) {
     host_.clear();
     return;
@@ -229,23 +191,15 @@ void Url::setHost(const std::string & host) {
   std::transform(host_.begin(), host_.end(), host_.begin(), ::tolower);
 }
 
-void Url::setPassword(const std::string & password) {
-  password_ = password;
-}
+void Url::setPassword(const std::string &password) { password_ = password; }
 
-void Url::setPath(const std::string & path) {
-  path_ = path;
-}
+void Url::setPath(const std::string &path) { path_ = path; }
 
-void Url::setPort(int port) {
-  port_ = port;
-}
+void Url::setPort(int port) { port_ = port; }
 
-void Url::setQuery(const std::string & query) {
-  query_ = query;
-}
+void Url::setQuery(const std::string &query) { query_ = query; }
 
-void Url::setScheme(const std::string & scheme) {
+void Url::setScheme(const std::string &scheme) {
   if (scheme.empty()) {
     scheme_.clear();
     return;
@@ -254,7 +208,7 @@ void Url::setScheme(const std::string & scheme) {
   std::transform(scheme_.begin(), scheme_.end(), scheme_.begin(), ::tolower);
 }
 
-void Url::setUserInfo(const std::string & userInfo) {
+void Url::setUserInfo(const std::string &userInfo) {
   if (userInfo.empty()) {
     userName_.clear();
     password_.clear();
@@ -270,9 +224,7 @@ void Url::setUserInfo(const std::string & userInfo) {
   }
 }
 
-void Url::setUserName(const std::string & userName) {
-  userName_ = userName;
-}
+void Url::setUserName(const std::string &userName) { userName_ = userName; }
 
 std::string Url::toString() const {
   if (!isValid())
@@ -306,8 +258,6 @@ std::string Url::userInfo() const {
   return out.str();
 }
 
-std::string Url::userName() const {
-  return userName_;
-}
+std::string Url::userName() const { return userName_; }
 
-}  // namespace AlibabaCloud
+} // namespace AlibabaCloud

core/src/Utils.cc

@@ -15,9 +15,9 @@
  */
 
 #include <algorithm>
+#include <alibabacloud/core/Utils.h>
 #include <sstream>
 #include <stdlib.h>
-#include <alibabacloud/core/Utils.h>
 
 #ifdef _WIN32
 #include <Windows.h>
@@ -29,8 +29,7 @@
 #include <curl/curl.h>
 #include <json/json.h>
 
-std::string AlibabaCloud::GenerateUuid()
-{
+std::string AlibabaCloud::GenerateUuid() {
 #ifdef _WIN32
   char *data;
   UUID uuidhandle;
@@ -48,8 +47,7 @@ std::string AlibabaCloud::GenerateUuid()
 #endif
 }
 
-std::string AlibabaCloud::UrlEncode(const std::string &src)
-{
+std::string AlibabaCloud::UrlEncode(const std::string &src) {
   CURL *curl = curl_easy_init();
   char *output = curl_easy_escape(curl, src.c_str(), src.size());
   std::string result(output);
@@ -58,8 +56,7 @@ std::string AlibabaCloud::UrlEncode(const std::string &src)
   return result;
 }
 
-std::string AlibabaCloud::UrlDecode(const std::string &src)
-{
+std::string AlibabaCloud::UrlDecode(const std::string &src) {
   CURL *curl = curl_easy_init();
   int outlength = 0;
   char *output = curl_easy_unescape(curl, src.c_str(), src.size(), &outlength);
@@ -69,8 +66,7 @@ std::string AlibabaCloud::UrlDecode(const std::string &src)
   return result;
 }
 
-std::string AlibabaCloud::ComputeContentMD5(const char *data, size_t size)
-{
+std::string AlibabaCloud::ComputeContentMD5(const char *data, size_t size) {
 #ifdef _WIN32
   HCRYPTPROV hProv = 0;
   HCRYPTHASH hHash = 0;
@@ -108,20 +104,16 @@ std::string AlibabaCloud::ComputeContentMD5(const char *data, size_t size)
 }
 
 void AlibabaCloud::StringReplace(std::string &src, const std::string &s1,
-                                 const std::string &s2)
-{
+                                 const std::string &s2) {
   std::string::size_type pos = 0;
-  while ((pos = src.find(s1, pos)) != std::string::npos)
-  {
+  while ((pos = src.find(s1, pos)) != std::string::npos) {
     src.replace(pos, s1.length(), s2);
     pos += s2.length();
   }
 }
 
-std::string AlibabaCloud::HttpMethodToString(HttpRequest::Method method)
-{
-  switch (method)
-  {
+std::string AlibabaCloud::HttpMethodToString(HttpRequest::Method method) {
+  switch (method) {
   case HttpRequest::Method::Head:
     return "HEAD";
     break;
@@ -154,14 +146,12 @@ std::string AlibabaCloud::HttpMethodToString(HttpRequest::Method method)
 }
 
 std::string AlibabaCloud::canonicalizedQuery(
-    const std::map<std::string, std::string> &params)
-{
+    const std::map<std::string, std::string> &params) {
   if (params.empty())
     return std::string();
 
   std::stringstream ss;
-  for (const auto &p : params)
-  {
+  for (const auto &p : params) {
     std::string key = UrlEncode(p.first);
     StringReplace(key, "+", "%20");
     StringReplace(key, "*", "%2A");
@@ -176,11 +166,9 @@ std::string AlibabaCloud::canonicalizedQuery(
 }
 
 std::string AlibabaCloud::canonicalizedHeaders(
-    const HttpMessage::HeaderCollection &headers)
-{
+    const HttpMessage::HeaderCollection &headers) {
   std::map<std::string, std::string> materials;
-  for (const auto &p : headers)
-  {
+  for (const auto &p : headers) {
     std::string key = p.first;
     std::transform(key.begin(), key.end(), key.begin(), ::tolower);
     if (key.find("x-acs-") != 0)
@@ -203,91 +191,78 @@ std::string AlibabaCloud::canonicalizedHeaders(
   return ss.str();
 }
 
-std::string AlibabaCloud::GetEnv(const std::string env)
-{
+std::string AlibabaCloud::GetEnv(const std::string env) {
 #ifdef _WIN32
   char *buf = nullptr;
   size_t sz = 0;
-  if (_dupenv_s(&buf, &sz, env.c_str()) == 0 && buf != nullptr)
-  {
+  if (_dupenv_s(&buf, &sz, env.c_str()) == 0 && buf != nullptr) {
     std::string var(buf);
     free(buf);
     return var;
-  }
-  else
-  {
-    if (buf)
-    {
+  } else {
+    if (buf) {
       free(buf);
     }
     return std::string();
   }
 #else
   char *var = getenv(env.c_str());
-  if (var)
-  {
+  if (var) {
     return std::string(var);
   }
   return std::string();
 #endif
 }
 
-std::string AlibabaCloud::MapToJson(const std::map<std::string, std::string> &maps)
-{
+std::string
+AlibabaCloud::MapToJson(const std::map<std::string, std::string> &maps) {
   Json::Value jsonObject;
-  Json::FastWriter writer; 
-  for (std::map<std::string, std::string>::const_iterator iter = maps.begin(); iter != maps.end(); ++iter)
-  {
+  Json::FastWriter writer;
+  for (std::map<std::string, std::string>::const_iterator iter = maps.begin();
+       iter != maps.end(); ++iter) {
     jsonObject[iter->first] = iter->second;
   }
   std::string unformat_str = writer.write(jsonObject);
   return unformat_str.substr(0, unformat_str.length() - 1);
 }
 
-std::map<std::string, std::string> AlibabaCloud::JsonToMap(const std::string &json)
-{
+std::map<std::string, std::string>
+AlibabaCloud::JsonToMap(const std::string &json) {
   Json::Reader reader;
   Json::Value value;
   std::map<std::string, std::string> maps;
 
-  if (json.length() > 0)
-  {
-    if (reader.parse(json, value))
-    {
+  if (json.length() > 0) {
+    if (reader.parse(json, value)) {
       Json::Value::Members members = value.getMemberNames();
-      for (Json::Value::Members::iterator it = members.begin(); it != members.end(); it++)
-      {
+      for (Json::Value::Members::iterator it = members.begin();
+           it != members.end(); ++it) {
         Json::ValueType vt = value[*it].type();
-        switch (vt)
-        {
-        case Json::stringValue:
-        {
-          maps.insert(std::pair<std::string, std::string>(*it, value[*it].asString()));
+        switch (vt) {
+        case Json::stringValue: {
+          maps.insert(
+              std::pair<std::string, std::string>(*it, value[*it].asString()));
           break;
         }
-        case Json::intValue:
-        {
+        case Json::intValue: {
           int inttmp = value[*it].asInt();
-          maps.insert(std::pair<std::string, std::string>(*it, std::to_string(inttmp)));
+          maps.insert(
+              std::pair<std::string, std::string>(*it, std::to_string(inttmp)));
           break;
         }
-        case Json::arrayValue:
-        {
+        case Json::arrayValue: {
           std::string strid;
-          for (unsigned int i = 0; i < value[*it].size(); i++)
-          {
+          for (unsigned int i = 0; i < value[*it].size(); i++) {
             strid += value[*it][i].asString();
             strid += ",";
           }
-          if (!strid.empty())
-          {
+          if (!strid.empty()) {
             strid = strid.substr(0, strid.size() - 1);
           }
           maps.insert(std::pair<std::string, std::string>(*it, strid));
           break;
         }
-        default:
-        {
+        default: {
           break;
         }
         }

dataworks-public/CMakeLists.txt

@@ -0,0 +1,506 @@
+#
+# 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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(dataworks-public_public_header 
+	include/alibabacloud/dataworks-public/Dataworks_publicClient.h
+	include/alibabacloud/dataworks-public/Dataworks_publicExport.h )
+
+set(dataworks-public_public_header_model 
+	include/alibabacloud/dataworks-public/model/AbolishDataServiceApiRequest.h
+	include/alibabacloud/dataworks-public/model/AbolishDataServiceApiResult.h
+	include/alibabacloud/dataworks-public/model/AddToMetaCategoryRequest.h
+	include/alibabacloud/dataworks-public/model/AddToMetaCategoryResult.h
+	include/alibabacloud/dataworks-public/model/CheckMetaPartitionRequest.h
+	include/alibabacloud/dataworks-public/model/CheckMetaPartitionResult.h
+	include/alibabacloud/dataworks-public/model/CheckMetaTableRequest.h
+	include/alibabacloud/dataworks-public/model/CheckMetaTableResult.h
+	include/alibabacloud/dataworks-public/model/CreateConnectionRequest.h
+	include/alibabacloud/dataworks-public/model/CreateConnectionResult.h
+	include/alibabacloud/dataworks-public/model/CreateDataServiceApiRequest.h
+	include/alibabacloud/dataworks-public/model/CreateDataServiceApiResult.h
+	include/alibabacloud/dataworks-public/model/CreateFileRequest.h
+	include/alibabacloud/dataworks-public/model/CreateFileResult.h
+	include/alibabacloud/dataworks-public/model/CreateFolderRequest.h
+	include/alibabacloud/dataworks-public/model/CreateFolderResult.h
+	include/alibabacloud/dataworks-public/model/CreateMetaCategoryRequest.h
+	include/alibabacloud/dataworks-public/model/CreateMetaCategoryResult.h
+	include/alibabacloud/dataworks-public/model/CreateNodeComplementRequest.h
+	include/alibabacloud/dataworks-public/model/CreateNodeComplementResult.h
+	include/alibabacloud/dataworks-public/model/CreateNodeTestRequest.h
+	include/alibabacloud/dataworks-public/model/CreateNodeTestResult.h
+	include/alibabacloud/dataworks-public/model/CreateQualityEntityRequest.h
+	include/alibabacloud/dataworks-public/model/CreateQualityEntityResult.h
+	include/alibabacloud/dataworks-public/model/CreateQualityFollowerRequest.h
+	include/alibabacloud/dataworks-public/model/CreateQualityFollowerResult.h
+	include/alibabacloud/dataworks-public/model/CreateQualityRelativeNodeRequest.h
+	include/alibabacloud/dataworks-public/model/CreateQualityRelativeNodeResult.h
+	include/alibabacloud/dataworks-public/model/CreateQualityRuleRequest.h
+	include/alibabacloud/dataworks-public/model/CreateQualityRuleResult.h
+	include/alibabacloud/dataworks-public/model/CreateRemindRequest.h
+	include/alibabacloud/dataworks-public/model/CreateRemindResult.h
+	include/alibabacloud/dataworks-public/model/CreateUdfFileRequest.h
+	include/alibabacloud/dataworks-public/model/CreateUdfFileResult.h
+	include/alibabacloud/dataworks-public/model/DeleteBusinessRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteBusinessResult.h
+	include/alibabacloud/dataworks-public/model/DeleteConnectionRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteConnectionResult.h
+	include/alibabacloud/dataworks-public/model/DeleteDataServiceApiRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteDataServiceApiResult.h
+	include/alibabacloud/dataworks-public/model/DeleteFileRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteFileResult.h
+	include/alibabacloud/dataworks-public/model/DeleteFolderRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteFolderResult.h
+	include/alibabacloud/dataworks-public/model/DeleteFromMetaCategoryRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteFromMetaCategoryResult.h
+	include/alibabacloud/dataworks-public/model/DeleteMetaCategoryRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteMetaCategoryResult.h
+	include/alibabacloud/dataworks-public/model/DeleteQualityEntityRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteQualityEntityResult.h
+	include/alibabacloud/dataworks-public/model/DeleteQualityFollowerRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteQualityFollowerResult.h
+	include/alibabacloud/dataworks-public/model/DeleteQualityRelativeNodeRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteQualityRelativeNodeResult.h
+	include/alibabacloud/dataworks-public/model/DeleteQualityRuleRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteQualityRuleResult.h
+	include/alibabacloud/dataworks-public/model/DeleteRemindRequest.h
+	include/alibabacloud/dataworks-public/model/DeleteRemindResult.h
+	include/alibabacloud/dataworks-public/model/DeployFileRequest.h
+	include/alibabacloud/dataworks-public/model/DeployFileResult.h
+	include/alibabacloud/dataworks-public/model/EstablishRelationTableToBusinessRequest.h
+	include/alibabacloud/dataworks-public/model/EstablishRelationTableToBusinessResult.h
+	include/alibabacloud/dataworks-public/model/GetBaselineConfigRequest.h
+	include/alibabacloud/dataworks-public/model/GetBaselineConfigResult.h
+	include/alibabacloud/dataworks-public/model/GetBaselineKeyPathRequest.h
+	include/alibabacloud/dataworks-public/model/GetBaselineKeyPathResult.h
+	include/alibabacloud/dataworks-public/model/GetBaselineStatusRequest.h
+	include/alibabacloud/dataworks-public/model/GetBaselineStatusResult.h
+	include/alibabacloud/dataworks-public/model/GetBusinessRequest.h
+	include/alibabacloud/dataworks-public/model/GetBusinessResult.h
+	include/alibabacloud/dataworks-public/model/GetDataServiceApiRequest.h
+	include/alibabacloud/dataworks-public/model/GetDataServiceApiResult.h
+	include/alibabacloud/dataworks-public/model/GetDataServiceApplicationRequest.h
+	include/alibabacloud/dataworks-public/model/GetDataServiceApplicationResult.h
+	include/alibabacloud/dataworks-public/model/GetDataServicePublishedApiRequest.h
+	include/alibabacloud/dataworks-public/model/GetDataServicePublishedApiResult.h
+	include/alibabacloud/dataworks-public/model/GetDeploymentRequest.h
+	include/alibabacloud/dataworks-public/model/GetDeploymentResult.h
+	include/alibabacloud/dataworks-public/model/GetFileRequest.h
+	include/alibabacloud/dataworks-public/model/GetFileResult.h
+	include/alibabacloud/dataworks-public/model/GetFileVersionRequest.h
+	include/alibabacloud/dataworks-public/model/GetFileVersionResult.h
+	include/alibabacloud/dataworks-public/model/GetFolderRequest.h
+	include/alibabacloud/dataworks-public/model/GetFolderResult.h
+	include/alibabacloud/dataworks-public/model/GetInstanceRequest.h
+	include/alibabacloud/dataworks-public/model/GetInstanceResult.h
+	include/alibabacloud/dataworks-public/model/GetInstanceLogRequest.h
+	include/alibabacloud/dataworks-public/model/GetInstanceLogResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaCategoryRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaCategoryResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaColumnLineageRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaColumnLineageResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaDBInfoRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaDBInfoResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaDBTableListRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaDBTableListResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableBasicInfoRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableBasicInfoResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableChangeLogRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableChangeLogResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableColumnRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableColumnResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableFullInfoRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableFullInfoResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableIntroWikiRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableIntroWikiResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableLineageRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableLineageResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableListByCategoryRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableListByCategoryResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableOutputRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaTableOutputResult.h
+	include/alibabacloud/dataworks-public/model/GetMetaTablePartitionRequest.h
+	include/alibabacloud/dataworks-public/model/GetMetaTablePartitionResult.h
+	include/alibabacloud/dataworks-public/model/GetNodeRequest.h
+	include/alibabacloud/dataworks-public/model/GetNodeResult.h
+	include/alibabacloud/dataworks-public/model/GetNodeCodeRequest.h
+	include/alibabacloud/dataworks-public/model/GetNodeCodeResult.h
+	include/alibabacloud/dataworks-public/model/GetNodeOnBaselineRequest.h
+	include/alibabacloud/dataworks-public/model/GetNodeOnBaselineResult.h
+	include/alibabacloud/dataworks-public/model/GetProjectDetailRequest.h
+	include/alibabacloud/dataworks-public/model/GetProjectDetailResult.h
+	include/alibabacloud/dataworks-public/model/GetQualityEntityRequest.h
+	include/alibabacloud/dataworks-public/model/GetQualityEntityResult.h
+	include/alibabacloud/dataworks-public/model/GetQualityFollowerRequest.h
+	include/alibabacloud/dataworks-public/model/GetQualityFollowerResult.h
+	include/alibabacloud/dataworks-public/model/GetQualityRuleRequest.h
+	include/alibabacloud/dataworks-public/model/GetQualityRuleResult.h
+	include/alibabacloud/dataworks-public/model/GetRemindRequest.h
+	include/alibabacloud/dataworks-public/model/GetRemindResult.h
+	include/alibabacloud/dataworks-public/model/GetTopicRequest.h
+	include/alibabacloud/dataworks-public/model/GetTopicResult.h
+	include/alibabacloud/dataworks-public/model/GetTopicInfluenceRequest.h
+	include/alibabacloud/dataworks-public/model/GetTopicInfluenceResult.h
+	include/alibabacloud/dataworks-public/model/ListAlertMessagesRequest.h
+	include/alibabacloud/dataworks-public/model/ListAlertMessagesResult.h
+	include/alibabacloud/dataworks-public/model/ListBaselineConfigsRequest.h
+	include/alibabacloud/dataworks-public/model/ListBaselineConfigsResult.h
+	include/alibabacloud/dataworks-public/model/ListBaselineStatusesRequest.h
+	include/alibabacloud/dataworks-public/model/ListBaselineStatusesResult.h
+	include/alibabacloud/dataworks-public/model/ListBusinessRequest.h
+	include/alibabacloud/dataworks-public/model/ListBusinessResult.h
+	include/alibabacloud/dataworks-public/model/ListCalcEnginesRequest.h
+	include/alibabacloud/dataworks-public/model/ListCalcEnginesResult.h
+	include/alibabacloud/dataworks-public/model/ListConnectionsRequest.h
+	include/alibabacloud/dataworks-public/model/ListConnectionsResult.h
+	include/alibabacloud/dataworks-public/model/ListDataServiceApiAuthoritiesRequest.h
+	include/alibabacloud/dataworks-public/model/ListDataServiceApiAuthoritiesResult.h
+	include/alibabacloud/dataworks-public/model/ListDataServiceApisRequest.h
+	include/alibabacloud/dataworks-public/model/ListDataServiceApisResult.h
+	include/alibabacloud/dataworks-public/model/ListDataServiceApplicationsRequest.h
+	include/alibabacloud/dataworks-public/model/ListDataServiceApplicationsResult.h
+	include/alibabacloud/dataworks-public/model/ListDataServiceAuthorizedApisRequest.h
+	include/alibabacloud/dataworks-public/model/ListDataServiceAuthorizedApisResult.h
+	include/alibabacloud/dataworks-public/model/ListDataServicePublishedApisRequest.h
+	include/alibabacloud/dataworks-public/model/ListDataServicePublishedApisResult.h
+	include/alibabacloud/dataworks-public/model/ListFileVersionsRequest.h
+	include/alibabacloud/dataworks-public/model/ListFileVersionsResult.h
+	include/alibabacloud/dataworks-public/model/ListFilesRequest.h
+	include/alibabacloud/dataworks-public/model/ListFilesResult.h
+	include/alibabacloud/dataworks-public/model/ListFoldersRequest.h
+	include/alibabacloud/dataworks-public/model/ListFoldersResult.h
+	include/alibabacloud/dataworks-public/model/ListInstancesRequest.h
+	include/alibabacloud/dataworks-public/model/ListInstancesResult.h
+	include/alibabacloud/dataworks-public/model/ListNodeIORequest.h
+	include/alibabacloud/dataworks-public/model/ListNodeIOResult.h
+	include/alibabacloud/dataworks-public/model/ListNodesRequest.h
+	include/alibabacloud/dataworks-public/model/ListNodesResult.h
+	include/alibabacloud/dataworks-public/model/ListQualityRulesRequest.h
+	include/alibabacloud/dataworks-public/model/ListQualityRulesResult.h
+	include/alibabacloud/dataworks-public/model/ListRemindsRequest.h
+	include/alibabacloud/dataworks-public/model/ListRemindsResult.h
+	include/alibabacloud/dataworks-public/model/ListResourceGroupsRequest.h
+	include/alibabacloud/dataworks-public/model/ListResourceGroupsResult.h
+	include/alibabacloud/dataworks-public/model/ListTopicsRequest.h
+	include/alibabacloud/dataworks-public/model/ListTopicsResult.h
+	include/alibabacloud/dataworks-public/model/PublishDataServiceApiRequest.h
+	include/alibabacloud/dataworks-public/model/PublishDataServiceApiResult.h
+	include/alibabacloud/dataworks-public/model/RestartInstanceRequest.h
+	include/alibabacloud/dataworks-public/model/RestartInstanceResult.h
+	include/alibabacloud/dataworks-public/model/ResumeInstanceRequest.h
+	include/alibabacloud/dataworks-public/model/ResumeInstanceResult.h
+	include/alibabacloud/dataworks-public/model/SearchMetaTablesRequest.h
+	include/alibabacloud/dataworks-public/model/SearchMetaTablesResult.h
+	include/alibabacloud/dataworks-public/model/SetSuccessInstanceRequest.h
+	include/alibabacloud/dataworks-public/model/SetSuccessInstanceResult.h
+	include/alibabacloud/dataworks-public/model/StopInstanceRequest.h
+	include/alibabacloud/dataworks-public/model/StopInstanceResult.h
+	include/alibabacloud/dataworks-public/model/SubmitFileRequest.h
+	include/alibabacloud/dataworks-public/model/SubmitFileResult.h
+	include/alibabacloud/dataworks-public/model/SuspendInstanceRequest.h
+	include/alibabacloud/dataworks-public/model/SuspendInstanceResult.h
+	include/alibabacloud/dataworks-public/model/UpdateBusinessRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateBusinessResult.h
+	include/alibabacloud/dataworks-public/model/UpdateConnectionRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateConnectionResult.h
+	include/alibabacloud/dataworks-public/model/UpdateDataServiceApiRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateDataServiceApiResult.h
+	include/alibabacloud/dataworks-public/model/UpdateFileRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateFileResult.h
+	include/alibabacloud/dataworks-public/model/UpdateFolderRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateFolderResult.h
+	include/alibabacloud/dataworks-public/model/UpdateMetaCategoryRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateMetaCategoryResult.h
+	include/alibabacloud/dataworks-public/model/UpdateQualityFollowerRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateQualityFollowerResult.h
+	include/alibabacloud/dataworks-public/model/UpdateQualityRuleRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateQualityRuleResult.h
+	include/alibabacloud/dataworks-public/model/UpdateRemindRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateRemindResult.h
+	include/alibabacloud/dataworks-public/model/UpdateUdfFileRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateUdfFileResult.h )
+
+set(dataworks-public_src 
+	src/Dataworks-publicClient.cc
+	src/model/AbolishDataServiceApiRequest.cc
+	src/model/AbolishDataServiceApiResult.cc
+	src/model/AddToMetaCategoryRequest.cc
+	src/model/AddToMetaCategoryResult.cc
+	src/model/CheckMetaPartitionRequest.cc
+	src/model/CheckMetaPartitionResult.cc
+	src/model/CheckMetaTableRequest.cc
+	src/model/CheckMetaTableResult.cc
+	src/model/CreateConnectionRequest.cc
+	src/model/CreateConnectionResult.cc
+	src/model/CreateDataServiceApiRequest.cc
+	src/model/CreateDataServiceApiResult.cc
+	src/model/CreateFileRequest.cc
+	src/model/CreateFileResult.cc
+	src/model/CreateFolderRequest.cc
+	src/model/CreateFolderResult.cc
+	src/model/CreateMetaCategoryRequest.cc
+	src/model/CreateMetaCategoryResult.cc
+	src/model/CreateNodeComplementRequest.cc
+	src/model/CreateNodeComplementResult.cc
+	src/model/CreateNodeTestRequest.cc
+	src/model/CreateNodeTestResult.cc
+	src/model/CreateQualityEntityRequest.cc
+	src/model/CreateQualityEntityResult.cc
+	src/model/CreateQualityFollowerRequest.cc
+	src/model/CreateQualityFollowerResult.cc
+	src/model/CreateQualityRelativeNodeRequest.cc
+	src/model/CreateQualityRelativeNodeResult.cc
+	src/model/CreateQualityRuleRequest.cc
+	src/model/CreateQualityRuleResult.cc
+	src/model/CreateRemindRequest.cc
+	src/model/CreateRemindResult.cc
+	src/model/CreateUdfFileRequest.cc
+	src/model/CreateUdfFileResult.cc
+	src/model/DeleteBusinessRequest.cc
+	src/model/DeleteBusinessResult.cc
+	src/model/DeleteConnectionRequest.cc
+	src/model/DeleteConnectionResult.cc
+	src/model/DeleteDataServiceApiRequest.cc
+	src/model/DeleteDataServiceApiResult.cc
+	src/model/DeleteFileRequest.cc
+	src/model/DeleteFileResult.cc
+	src/model/DeleteFolderRequest.cc
+	src/model/DeleteFolderResult.cc
+	src/model/DeleteFromMetaCategoryRequest.cc
+	src/model/DeleteFromMetaCategoryResult.cc
+	src/model/DeleteMetaCategoryRequest.cc
+	src/model/DeleteMetaCategoryResult.cc
+	src/model/DeleteQualityEntityRequest.cc
+	src/model/DeleteQualityEntityResult.cc
+	src/model/DeleteQualityFollowerRequest.cc
+	src/model/DeleteQualityFollowerResult.cc
+	src/model/DeleteQualityRelativeNodeRequest.cc
+	src/model/DeleteQualityRelativeNodeResult.cc
+	src/model/DeleteQualityRuleRequest.cc
+	src/model/DeleteQualityRuleResult.cc
+	src/model/DeleteRemindRequest.cc
+	src/model/DeleteRemindResult.cc
+	src/model/DeployFileRequest.cc
+	src/model/DeployFileResult.cc
+	src/model/EstablishRelationTableToBusinessRequest.cc
+	src/model/EstablishRelationTableToBusinessResult.cc
+	src/model/GetBaselineConfigRequest.cc
+	src/model/GetBaselineConfigResult.cc
+	src/model/GetBaselineKeyPathRequest.cc
+	src/model/GetBaselineKeyPathResult.cc
+	src/model/GetBaselineStatusRequest.cc
+	src/model/GetBaselineStatusResult.cc
+	src/model/GetBusinessRequest.cc
+	src/model/GetBusinessResult.cc
+	src/model/GetDataServiceApiRequest.cc
+	src/model/GetDataServiceApiResult.cc
+	src/model/GetDataServiceApplicationRequest.cc
+	src/model/GetDataServiceApplicationResult.cc
+	src/model/GetDataServicePublishedApiRequest.cc
+	src/model/GetDataServicePublishedApiResult.cc
+	src/model/GetDeploymentRequest.cc
+	src/model/GetDeploymentResult.cc
+	src/model/GetFileRequest.cc
+	src/model/GetFileResult.cc
+	src/model/GetFileVersionRequest.cc
+	src/model/GetFileVersionResult.cc
+	src/model/GetFolderRequest.cc
+	src/model/GetFolderResult.cc
+	src/model/GetInstanceRequest.cc
+	src/model/GetInstanceResult.cc
+	src/model/GetInstanceLogRequest.cc
+	src/model/GetInstanceLogResult.cc
+	src/model/GetMetaCategoryRequest.cc
+	src/model/GetMetaCategoryResult.cc
+	src/model/GetMetaColumnLineageRequest.cc
+	src/model/GetMetaColumnLineageResult.cc
+	src/model/GetMetaDBInfoRequest.cc
+	src/model/GetMetaDBInfoResult.cc
+	src/model/GetMetaDBTableListRequest.cc
+	src/model/GetMetaDBTableListResult.cc
+	src/model/GetMetaTableBasicInfoRequest.cc
+	src/model/GetMetaTableBasicInfoResult.cc
+	src/model/GetMetaTableChangeLogRequest.cc
+	src/model/GetMetaTableChangeLogResult.cc
+	src/model/GetMetaTableColumnRequest.cc
+	src/model/GetMetaTableColumnResult.cc
+	src/model/GetMetaTableFullInfoRequest.cc
+	src/model/GetMetaTableFullInfoResult.cc
+	src/model/GetMetaTableIntroWikiRequest.cc
+	src/model/GetMetaTableIntroWikiResult.cc
+	src/model/GetMetaTableLineageRequest.cc
+	src/model/GetMetaTableLineageResult.cc
+	src/model/GetMetaTableListByCategoryRequest.cc
+	src/model/GetMetaTableListByCategoryResult.cc
+	src/model/GetMetaTableOutputRequest.cc
+	src/model/GetMetaTableOutputResult.cc
+	src/model/GetMetaTablePartitionRequest.cc
+	src/model/GetMetaTablePartitionResult.cc
+	src/model/GetNodeRequest.cc
+	src/model/GetNodeResult.cc
+	src/model/GetNodeCodeRequest.cc
+	src/model/GetNodeCodeResult.cc
+	src/model/GetNodeOnBaselineRequest.cc
+	src/model/GetNodeOnBaselineResult.cc
+	src/model/GetProjectDetailRequest.cc
+	src/model/GetProjectDetailResult.cc
+	src/model/GetQualityEntityRequest.cc
+	src/model/GetQualityEntityResult.cc
+	src/model/GetQualityFollowerRequest.cc
+	src/model/GetQualityFollowerResult.cc
+	src/model/GetQualityRuleRequest.cc
+	src/model/GetQualityRuleResult.cc
+	src/model/GetRemindRequest.cc
+	src/model/GetRemindResult.cc
+	src/model/GetTopicRequest.cc
+	src/model/GetTopicResult.cc
+	src/model/GetTopicInfluenceRequest.cc
+	src/model/GetTopicInfluenceResult.cc
+	src/model/ListAlertMessagesRequest.cc
+	src/model/ListAlertMessagesResult.cc
+	src/model/ListBaselineConfigsRequest.cc
+	src/model/ListBaselineConfigsResult.cc
+	src/model/ListBaselineStatusesRequest.cc
+	src/model/ListBaselineStatusesResult.cc
+	src/model/ListBusinessRequest.cc
+	src/model/ListBusinessResult.cc
+	src/model/ListCalcEnginesRequest.cc
+	src/model/ListCalcEnginesResult.cc
+	src/model/ListConnectionsRequest.cc
+	src/model/ListConnectionsResult.cc
+	src/model/ListDataServiceApiAuthoritiesRequest.cc
+	src/model/ListDataServiceApiAuthoritiesResult.cc
+	src/model/ListDataServiceApisRequest.cc
+	src/model/ListDataServiceApisResult.cc
+	src/model/ListDataServiceApplicationsRequest.cc
+	src/model/ListDataServiceApplicationsResult.cc
+	src/model/ListDataServiceAuthorizedApisRequest.cc
+	src/model/ListDataServiceAuthorizedApisResult.cc
+	src/model/ListDataServicePublishedApisRequest.cc
+	src/model/ListDataServicePublishedApisResult.cc
+	src/model/ListFileVersionsRequest.cc
+	src/model/ListFileVersionsResult.cc
+	src/model/ListFilesRequest.cc
+	src/model/ListFilesResult.cc
+	src/model/ListFoldersRequest.cc
+	src/model/ListFoldersResult.cc
+	src/model/ListInstancesRequest.cc
+	src/model/ListInstancesResult.cc
+	src/model/ListNodeIORequest.cc
+	src/model/ListNodeIOResult.cc
+	src/model/ListNodesRequest.cc
+	src/model/ListNodesResult.cc
+	src/model/ListQualityRulesRequest.cc
+	src/model/ListQualityRulesResult.cc
+	src/model/ListRemindsRequest.cc
+	src/model/ListRemindsResult.cc
+	src/model/ListResourceGroupsRequest.cc
+	src/model/ListResourceGroupsResult.cc
+	src/model/ListTopicsRequest.cc
+	src/model/ListTopicsResult.cc
+	src/model/PublishDataServiceApiRequest.cc
+	src/model/PublishDataServiceApiResult.cc
+	src/model/RestartInstanceRequest.cc
+	src/model/RestartInstanceResult.cc
+	src/model/ResumeInstanceRequest.cc
+	src/model/ResumeInstanceResult.cc
+	src/model/SearchMetaTablesRequest.cc
+	src/model/SearchMetaTablesResult.cc
+	src/model/SetSuccessInstanceRequest.cc
+	src/model/SetSuccessInstanceResult.cc
+	src/model/StopInstanceRequest.cc
+	src/model/StopInstanceResult.cc
+	src/model/SubmitFileRequest.cc
+	src/model/SubmitFileResult.cc
+	src/model/SuspendInstanceRequest.cc
+	src/model/SuspendInstanceResult.cc
+	src/model/UpdateBusinessRequest.cc
+	src/model/UpdateBusinessResult.cc
+	src/model/UpdateConnectionRequest.cc
+	src/model/UpdateConnectionResult.cc
+	src/model/UpdateDataServiceApiRequest.cc
+	src/model/UpdateDataServiceApiResult.cc
+	src/model/UpdateFileRequest.cc
+	src/model/UpdateFileResult.cc
+	src/model/UpdateFolderRequest.cc
+	src/model/UpdateFolderResult.cc
+	src/model/UpdateMetaCategoryRequest.cc
+	src/model/UpdateMetaCategoryResult.cc
+	src/model/UpdateQualityFollowerRequest.cc
+	src/model/UpdateQualityFollowerResult.cc
+	src/model/UpdateQualityRuleRequest.cc
+	src/model/UpdateQualityRuleResult.cc
+	src/model/UpdateRemindRequest.cc
+	src/model/UpdateRemindResult.cc
+	src/model/UpdateUdfFileRequest.cc
+	src/model/UpdateUdfFileResult.cc )
+
+add_library(dataworks-public ${LIB_TYPE}
+	${dataworks-public_public_header}
+	${dataworks-public_public_header_model}
+	${dataworks-public_src})
+
+set_target_properties(dataworks-public
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}dataworks-public
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(dataworks-public
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_DATAWORKS_PUBLIC_LIBRARY)
+endif()
+
+target_include_directories(dataworks-public
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(dataworks-public
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(dataworks-public
+		jsoncpp)
+	target_include_directories(dataworks-public
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(dataworks-public
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(dataworks-public
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(dataworks-public
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(dataworks-public
+		jsoncpp)
+endif()
+
+install(FILES ${dataworks-public_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/dataworks-public)
+install(FILES ${dataworks-public_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/dataworks-public/model)
+install(TARGETS dataworks-public
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

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

@@ -0,0 +1,894 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_DATAWORKS_PUBLICCLIENT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_DATAWORKS_PUBLICCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "Dataworks_publicExport.h"
+#include "model/AbolishDataServiceApiRequest.h"
+#include "model/AbolishDataServiceApiResult.h"
+#include "model/AddToMetaCategoryRequest.h"
+#include "model/AddToMetaCategoryResult.h"
+#include "model/CheckMetaPartitionRequest.h"
+#include "model/CheckMetaPartitionResult.h"
+#include "model/CheckMetaTableRequest.h"
+#include "model/CheckMetaTableResult.h"
+#include "model/CreateConnectionRequest.h"
+#include "model/CreateConnectionResult.h"
+#include "model/CreateDataServiceApiRequest.h"
+#include "model/CreateDataServiceApiResult.h"
+#include "model/CreateFileRequest.h"
+#include "model/CreateFileResult.h"
+#include "model/CreateFolderRequest.h"
+#include "model/CreateFolderResult.h"
+#include "model/CreateMetaCategoryRequest.h"
+#include "model/CreateMetaCategoryResult.h"
+#include "model/CreateNodeComplementRequest.h"
+#include "model/CreateNodeComplementResult.h"
+#include "model/CreateNodeTestRequest.h"
+#include "model/CreateNodeTestResult.h"
+#include "model/CreateQualityEntityRequest.h"
+#include "model/CreateQualityEntityResult.h"
+#include "model/CreateQualityFollowerRequest.h"
+#include "model/CreateQualityFollowerResult.h"
+#include "model/CreateQualityRelativeNodeRequest.h"
+#include "model/CreateQualityRelativeNodeResult.h"
+#include "model/CreateQualityRuleRequest.h"
+#include "model/CreateQualityRuleResult.h"
+#include "model/CreateRemindRequest.h"
+#include "model/CreateRemindResult.h"
+#include "model/CreateUdfFileRequest.h"
+#include "model/CreateUdfFileResult.h"
+#include "model/DeleteBusinessRequest.h"
+#include "model/DeleteBusinessResult.h"
+#include "model/DeleteConnectionRequest.h"
+#include "model/DeleteConnectionResult.h"
+#include "model/DeleteDataServiceApiRequest.h"
+#include "model/DeleteDataServiceApiResult.h"
+#include "model/DeleteFileRequest.h"
+#include "model/DeleteFileResult.h"
+#include "model/DeleteFolderRequest.h"
+#include "model/DeleteFolderResult.h"
+#include "model/DeleteFromMetaCategoryRequest.h"
+#include "model/DeleteFromMetaCategoryResult.h"
+#include "model/DeleteMetaCategoryRequest.h"
+#include "model/DeleteMetaCategoryResult.h"
+#include "model/DeleteQualityEntityRequest.h"
+#include "model/DeleteQualityEntityResult.h"
+#include "model/DeleteQualityFollowerRequest.h"
+#include "model/DeleteQualityFollowerResult.h"
+#include "model/DeleteQualityRelativeNodeRequest.h"
+#include "model/DeleteQualityRelativeNodeResult.h"
+#include "model/DeleteQualityRuleRequest.h"
+#include "model/DeleteQualityRuleResult.h"
+#include "model/DeleteRemindRequest.h"
+#include "model/DeleteRemindResult.h"
+#include "model/DeployFileRequest.h"
+#include "model/DeployFileResult.h"
+#include "model/EstablishRelationTableToBusinessRequest.h"
+#include "model/EstablishRelationTableToBusinessResult.h"
+#include "model/GetBaselineConfigRequest.h"
+#include "model/GetBaselineConfigResult.h"
+#include "model/GetBaselineKeyPathRequest.h"
+#include "model/GetBaselineKeyPathResult.h"
+#include "model/GetBaselineStatusRequest.h"
+#include "model/GetBaselineStatusResult.h"
+#include "model/GetBusinessRequest.h"
+#include "model/GetBusinessResult.h"
+#include "model/GetDataServiceApiRequest.h"
+#include "model/GetDataServiceApiResult.h"
+#include "model/GetDataServiceApplicationRequest.h"
+#include "model/GetDataServiceApplicationResult.h"
+#include "model/GetDataServicePublishedApiRequest.h"
+#include "model/GetDataServicePublishedApiResult.h"
+#include "model/GetDeploymentRequest.h"
+#include "model/GetDeploymentResult.h"
+#include "model/GetFileRequest.h"
+#include "model/GetFileResult.h"
+#include "model/GetFileVersionRequest.h"
+#include "model/GetFileVersionResult.h"
+#include "model/GetFolderRequest.h"
+#include "model/GetFolderResult.h"
+#include "model/GetInstanceRequest.h"
+#include "model/GetInstanceResult.h"
+#include "model/GetInstanceLogRequest.h"
+#include "model/GetInstanceLogResult.h"
+#include "model/GetMetaCategoryRequest.h"
+#include "model/GetMetaCategoryResult.h"
+#include "model/GetMetaColumnLineageRequest.h"
+#include "model/GetMetaColumnLineageResult.h"
+#include "model/GetMetaDBInfoRequest.h"
+#include "model/GetMetaDBInfoResult.h"
+#include "model/GetMetaDBTableListRequest.h"
+#include "model/GetMetaDBTableListResult.h"
+#include "model/GetMetaTableBasicInfoRequest.h"
+#include "model/GetMetaTableBasicInfoResult.h"
+#include "model/GetMetaTableChangeLogRequest.h"
+#include "model/GetMetaTableChangeLogResult.h"
+#include "model/GetMetaTableColumnRequest.h"
+#include "model/GetMetaTableColumnResult.h"
+#include "model/GetMetaTableFullInfoRequest.h"
+#include "model/GetMetaTableFullInfoResult.h"
+#include "model/GetMetaTableIntroWikiRequest.h"
+#include "model/GetMetaTableIntroWikiResult.h"
+#include "model/GetMetaTableLineageRequest.h"
+#include "model/GetMetaTableLineageResult.h"
+#include "model/GetMetaTableListByCategoryRequest.h"
+#include "model/GetMetaTableListByCategoryResult.h"
+#include "model/GetMetaTableOutputRequest.h"
+#include "model/GetMetaTableOutputResult.h"
+#include "model/GetMetaTablePartitionRequest.h"
+#include "model/GetMetaTablePartitionResult.h"
+#include "model/GetNodeRequest.h"
+#include "model/GetNodeResult.h"
+#include "model/GetNodeCodeRequest.h"
+#include "model/GetNodeCodeResult.h"
+#include "model/GetNodeOnBaselineRequest.h"
+#include "model/GetNodeOnBaselineResult.h"
+#include "model/GetProjectDetailRequest.h"
+#include "model/GetProjectDetailResult.h"
+#include "model/GetQualityEntityRequest.h"
+#include "model/GetQualityEntityResult.h"
+#include "model/GetQualityFollowerRequest.h"
+#include "model/GetQualityFollowerResult.h"
+#include "model/GetQualityRuleRequest.h"
+#include "model/GetQualityRuleResult.h"
+#include "model/GetRemindRequest.h"
+#include "model/GetRemindResult.h"
+#include "model/GetTopicRequest.h"
+#include "model/GetTopicResult.h"
+#include "model/GetTopicInfluenceRequest.h"
+#include "model/GetTopicInfluenceResult.h"
+#include "model/ListAlertMessagesRequest.h"
+#include "model/ListAlertMessagesResult.h"
+#include "model/ListBaselineConfigsRequest.h"
+#include "model/ListBaselineConfigsResult.h"
+#include "model/ListBaselineStatusesRequest.h"
+#include "model/ListBaselineStatusesResult.h"
+#include "model/ListBusinessRequest.h"
+#include "model/ListBusinessResult.h"
+#include "model/ListCalcEnginesRequest.h"
+#include "model/ListCalcEnginesResult.h"
+#include "model/ListConnectionsRequest.h"
+#include "model/ListConnectionsResult.h"
+#include "model/ListDataServiceApiAuthoritiesRequest.h"
+#include "model/ListDataServiceApiAuthoritiesResult.h"
+#include "model/ListDataServiceApisRequest.h"
+#include "model/ListDataServiceApisResult.h"
+#include "model/ListDataServiceApplicationsRequest.h"
+#include "model/ListDataServiceApplicationsResult.h"
+#include "model/ListDataServiceAuthorizedApisRequest.h"
+#include "model/ListDataServiceAuthorizedApisResult.h"
+#include "model/ListDataServicePublishedApisRequest.h"
+#include "model/ListDataServicePublishedApisResult.h"
+#include "model/ListFileVersionsRequest.h"
+#include "model/ListFileVersionsResult.h"
+#include "model/ListFilesRequest.h"
+#include "model/ListFilesResult.h"
+#include "model/ListFoldersRequest.h"
+#include "model/ListFoldersResult.h"
+#include "model/ListInstancesRequest.h"
+#include "model/ListInstancesResult.h"
+#include "model/ListNodeIORequest.h"
+#include "model/ListNodeIOResult.h"
+#include "model/ListNodesRequest.h"
+#include "model/ListNodesResult.h"
+#include "model/ListQualityRulesRequest.h"
+#include "model/ListQualityRulesResult.h"
+#include "model/ListRemindsRequest.h"
+#include "model/ListRemindsResult.h"
+#include "model/ListResourceGroupsRequest.h"
+#include "model/ListResourceGroupsResult.h"
+#include "model/ListTopicsRequest.h"
+#include "model/ListTopicsResult.h"
+#include "model/PublishDataServiceApiRequest.h"
+#include "model/PublishDataServiceApiResult.h"
+#include "model/RestartInstanceRequest.h"
+#include "model/RestartInstanceResult.h"
+#include "model/ResumeInstanceRequest.h"
+#include "model/ResumeInstanceResult.h"
+#include "model/SearchMetaTablesRequest.h"
+#include "model/SearchMetaTablesResult.h"
+#include "model/SetSuccessInstanceRequest.h"
+#include "model/SetSuccessInstanceResult.h"
+#include "model/StopInstanceRequest.h"
+#include "model/StopInstanceResult.h"
+#include "model/SubmitFileRequest.h"
+#include "model/SubmitFileResult.h"
+#include "model/SuspendInstanceRequest.h"
+#include "model/SuspendInstanceResult.h"
+#include "model/UpdateBusinessRequest.h"
+#include "model/UpdateBusinessResult.h"
+#include "model/UpdateConnectionRequest.h"
+#include "model/UpdateConnectionResult.h"
+#include "model/UpdateDataServiceApiRequest.h"
+#include "model/UpdateDataServiceApiResult.h"
+#include "model/UpdateFileRequest.h"
+#include "model/UpdateFileResult.h"
+#include "model/UpdateFolderRequest.h"
+#include "model/UpdateFolderResult.h"
+#include "model/UpdateMetaCategoryRequest.h"
+#include "model/UpdateMetaCategoryResult.h"
+#include "model/UpdateQualityFollowerRequest.h"
+#include "model/UpdateQualityFollowerResult.h"
+#include "model/UpdateQualityRuleRequest.h"
+#include "model/UpdateQualityRuleResult.h"
+#include "model/UpdateRemindRequest.h"
+#include "model/UpdateRemindResult.h"
+#include "model/UpdateUdfFileRequest.h"
+#include "model/UpdateUdfFileResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT Dataworks_publicClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AbolishDataServiceApiResult> AbolishDataServiceApiOutcome;
+			typedef std::future<AbolishDataServiceApiOutcome> AbolishDataServiceApiOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::AbolishDataServiceApiRequest&, const AbolishDataServiceApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AbolishDataServiceApiAsyncHandler;
+			typedef Outcome<Error, Model::AddToMetaCategoryResult> AddToMetaCategoryOutcome;
+			typedef std::future<AddToMetaCategoryOutcome> AddToMetaCategoryOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::AddToMetaCategoryRequest&, const AddToMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddToMetaCategoryAsyncHandler;
+			typedef Outcome<Error, Model::CheckMetaPartitionResult> CheckMetaPartitionOutcome;
+			typedef std::future<CheckMetaPartitionOutcome> CheckMetaPartitionOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CheckMetaPartitionRequest&, const CheckMetaPartitionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckMetaPartitionAsyncHandler;
+			typedef Outcome<Error, Model::CheckMetaTableResult> CheckMetaTableOutcome;
+			typedef std::future<CheckMetaTableOutcome> CheckMetaTableOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CheckMetaTableRequest&, const CheckMetaTableOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckMetaTableAsyncHandler;
+			typedef Outcome<Error, Model::CreateConnectionResult> CreateConnectionOutcome;
+			typedef std::future<CreateConnectionOutcome> CreateConnectionOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateConnectionRequest&, const CreateConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateConnectionAsyncHandler;
+			typedef Outcome<Error, Model::CreateDataServiceApiResult> CreateDataServiceApiOutcome;
+			typedef std::future<CreateDataServiceApiOutcome> CreateDataServiceApiOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateDataServiceApiRequest&, const CreateDataServiceApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDataServiceApiAsyncHandler;
+			typedef Outcome<Error, Model::CreateFileResult> CreateFileOutcome;
+			typedef std::future<CreateFileOutcome> CreateFileOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateFileRequest&, const CreateFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFileAsyncHandler;
+			typedef Outcome<Error, Model::CreateFolderResult> CreateFolderOutcome;
+			typedef std::future<CreateFolderOutcome> CreateFolderOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateFolderRequest&, const CreateFolderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFolderAsyncHandler;
+			typedef Outcome<Error, Model::CreateMetaCategoryResult> CreateMetaCategoryOutcome;
+			typedef std::future<CreateMetaCategoryOutcome> CreateMetaCategoryOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateMetaCategoryRequest&, const CreateMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMetaCategoryAsyncHandler;
+			typedef Outcome<Error, Model::CreateNodeComplementResult> CreateNodeComplementOutcome;
+			typedef std::future<CreateNodeComplementOutcome> CreateNodeComplementOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateNodeComplementRequest&, const CreateNodeComplementOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNodeComplementAsyncHandler;
+			typedef Outcome<Error, Model::CreateNodeTestResult> CreateNodeTestOutcome;
+			typedef std::future<CreateNodeTestOutcome> CreateNodeTestOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateNodeTestRequest&, const CreateNodeTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNodeTestAsyncHandler;
+			typedef Outcome<Error, Model::CreateQualityEntityResult> CreateQualityEntityOutcome;
+			typedef std::future<CreateQualityEntityOutcome> CreateQualityEntityOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateQualityEntityRequest&, const CreateQualityEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateQualityEntityAsyncHandler;
+			typedef Outcome<Error, Model::CreateQualityFollowerResult> CreateQualityFollowerOutcome;
+			typedef std::future<CreateQualityFollowerOutcome> CreateQualityFollowerOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateQualityFollowerRequest&, const CreateQualityFollowerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateQualityFollowerAsyncHandler;
+			typedef Outcome<Error, Model::CreateQualityRelativeNodeResult> CreateQualityRelativeNodeOutcome;
+			typedef std::future<CreateQualityRelativeNodeOutcome> CreateQualityRelativeNodeOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateQualityRelativeNodeRequest&, const CreateQualityRelativeNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateQualityRelativeNodeAsyncHandler;
+			typedef Outcome<Error, Model::CreateQualityRuleResult> CreateQualityRuleOutcome;
+			typedef std::future<CreateQualityRuleOutcome> CreateQualityRuleOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateQualityRuleRequest&, const CreateQualityRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateQualityRuleAsyncHandler;
+			typedef Outcome<Error, Model::CreateRemindResult> CreateRemindOutcome;
+			typedef std::future<CreateRemindOutcome> CreateRemindOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateRemindRequest&, const CreateRemindOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRemindAsyncHandler;
+			typedef Outcome<Error, Model::CreateUdfFileResult> CreateUdfFileOutcome;
+			typedef std::future<CreateUdfFileOutcome> CreateUdfFileOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateUdfFileRequest&, const CreateUdfFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateUdfFileAsyncHandler;
+			typedef Outcome<Error, Model::DeleteBusinessResult> DeleteBusinessOutcome;
+			typedef std::future<DeleteBusinessOutcome> DeleteBusinessOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteBusinessRequest&, const DeleteBusinessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteBusinessAsyncHandler;
+			typedef Outcome<Error, Model::DeleteConnectionResult> DeleteConnectionOutcome;
+			typedef std::future<DeleteConnectionOutcome> DeleteConnectionOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteConnectionRequest&, const DeleteConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteConnectionAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDataServiceApiResult> DeleteDataServiceApiOutcome;
+			typedef std::future<DeleteDataServiceApiOutcome> DeleteDataServiceApiOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteDataServiceApiRequest&, const DeleteDataServiceApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDataServiceApiAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFileResult> DeleteFileOutcome;
+			typedef std::future<DeleteFileOutcome> DeleteFileOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteFileRequest&, const DeleteFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFileAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFolderResult> DeleteFolderOutcome;
+			typedef std::future<DeleteFolderOutcome> DeleteFolderOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteFolderRequest&, const DeleteFolderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFolderAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFromMetaCategoryResult> DeleteFromMetaCategoryOutcome;
+			typedef std::future<DeleteFromMetaCategoryOutcome> DeleteFromMetaCategoryOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteFromMetaCategoryRequest&, const DeleteFromMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFromMetaCategoryAsyncHandler;
+			typedef Outcome<Error, Model::DeleteMetaCategoryResult> DeleteMetaCategoryOutcome;
+			typedef std::future<DeleteMetaCategoryOutcome> DeleteMetaCategoryOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteMetaCategoryRequest&, const DeleteMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMetaCategoryAsyncHandler;
+			typedef Outcome<Error, Model::DeleteQualityEntityResult> DeleteQualityEntityOutcome;
+			typedef std::future<DeleteQualityEntityOutcome> DeleteQualityEntityOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteQualityEntityRequest&, const DeleteQualityEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteQualityEntityAsyncHandler;
+			typedef Outcome<Error, Model::DeleteQualityFollowerResult> DeleteQualityFollowerOutcome;
+			typedef std::future<DeleteQualityFollowerOutcome> DeleteQualityFollowerOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteQualityFollowerRequest&, const DeleteQualityFollowerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteQualityFollowerAsyncHandler;
+			typedef Outcome<Error, Model::DeleteQualityRelativeNodeResult> DeleteQualityRelativeNodeOutcome;
+			typedef std::future<DeleteQualityRelativeNodeOutcome> DeleteQualityRelativeNodeOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteQualityRelativeNodeRequest&, const DeleteQualityRelativeNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteQualityRelativeNodeAsyncHandler;
+			typedef Outcome<Error, Model::DeleteQualityRuleResult> DeleteQualityRuleOutcome;
+			typedef std::future<DeleteQualityRuleOutcome> DeleteQualityRuleOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteQualityRuleRequest&, const DeleteQualityRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteQualityRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteRemindResult> DeleteRemindOutcome;
+			typedef std::future<DeleteRemindOutcome> DeleteRemindOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeleteRemindRequest&, const DeleteRemindOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRemindAsyncHandler;
+			typedef Outcome<Error, Model::DeployFileResult> DeployFileOutcome;
+			typedef std::future<DeployFileOutcome> DeployFileOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::DeployFileRequest&, const DeployFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeployFileAsyncHandler;
+			typedef Outcome<Error, Model::EstablishRelationTableToBusinessResult> EstablishRelationTableToBusinessOutcome;
+			typedef std::future<EstablishRelationTableToBusinessOutcome> EstablishRelationTableToBusinessOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::EstablishRelationTableToBusinessRequest&, const EstablishRelationTableToBusinessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EstablishRelationTableToBusinessAsyncHandler;
+			typedef Outcome<Error, Model::GetBaselineConfigResult> GetBaselineConfigOutcome;
+			typedef std::future<GetBaselineConfigOutcome> GetBaselineConfigOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetBaselineConfigRequest&, const GetBaselineConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBaselineConfigAsyncHandler;
+			typedef Outcome<Error, Model::GetBaselineKeyPathResult> GetBaselineKeyPathOutcome;
+			typedef std::future<GetBaselineKeyPathOutcome> GetBaselineKeyPathOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetBaselineKeyPathRequest&, const GetBaselineKeyPathOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBaselineKeyPathAsyncHandler;
+			typedef Outcome<Error, Model::GetBaselineStatusResult> GetBaselineStatusOutcome;
+			typedef std::future<GetBaselineStatusOutcome> GetBaselineStatusOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetBaselineStatusRequest&, const GetBaselineStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBaselineStatusAsyncHandler;
+			typedef Outcome<Error, Model::GetBusinessResult> GetBusinessOutcome;
+			typedef std::future<GetBusinessOutcome> GetBusinessOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetBusinessRequest&, const GetBusinessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBusinessAsyncHandler;
+			typedef Outcome<Error, Model::GetDataServiceApiResult> GetDataServiceApiOutcome;
+			typedef std::future<GetDataServiceApiOutcome> GetDataServiceApiOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetDataServiceApiRequest&, const GetDataServiceApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDataServiceApiAsyncHandler;
+			typedef Outcome<Error, Model::GetDataServiceApplicationResult> GetDataServiceApplicationOutcome;
+			typedef std::future<GetDataServiceApplicationOutcome> GetDataServiceApplicationOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetDataServiceApplicationRequest&, const GetDataServiceApplicationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDataServiceApplicationAsyncHandler;
+			typedef Outcome<Error, Model::GetDataServicePublishedApiResult> GetDataServicePublishedApiOutcome;
+			typedef std::future<GetDataServicePublishedApiOutcome> GetDataServicePublishedApiOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetDataServicePublishedApiRequest&, const GetDataServicePublishedApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDataServicePublishedApiAsyncHandler;
+			typedef Outcome<Error, Model::GetDeploymentResult> GetDeploymentOutcome;
+			typedef std::future<GetDeploymentOutcome> GetDeploymentOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetDeploymentRequest&, const GetDeploymentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDeploymentAsyncHandler;
+			typedef Outcome<Error, Model::GetFileResult> GetFileOutcome;
+			typedef std::future<GetFileOutcome> GetFileOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetFileRequest&, const GetFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFileAsyncHandler;
+			typedef Outcome<Error, Model::GetFileVersionResult> GetFileVersionOutcome;
+			typedef std::future<GetFileVersionOutcome> GetFileVersionOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetFileVersionRequest&, const GetFileVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFileVersionAsyncHandler;
+			typedef Outcome<Error, Model::GetFolderResult> GetFolderOutcome;
+			typedef std::future<GetFolderOutcome> GetFolderOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetFolderRequest&, const GetFolderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFolderAsyncHandler;
+			typedef Outcome<Error, Model::GetInstanceResult> GetInstanceOutcome;
+			typedef std::future<GetInstanceOutcome> GetInstanceOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetInstanceRequest&, const GetInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceAsyncHandler;
+			typedef Outcome<Error, Model::GetInstanceLogResult> GetInstanceLogOutcome;
+			typedef std::future<GetInstanceLogOutcome> GetInstanceLogOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetInstanceLogRequest&, const GetInstanceLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceLogAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaCategoryResult> GetMetaCategoryOutcome;
+			typedef std::future<GetMetaCategoryOutcome> GetMetaCategoryOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaCategoryRequest&, const GetMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaCategoryAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaColumnLineageResult> GetMetaColumnLineageOutcome;
+			typedef std::future<GetMetaColumnLineageOutcome> GetMetaColumnLineageOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaColumnLineageRequest&, const GetMetaColumnLineageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaColumnLineageAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaDBInfoResult> GetMetaDBInfoOutcome;
+			typedef std::future<GetMetaDBInfoOutcome> GetMetaDBInfoOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaDBInfoRequest&, const GetMetaDBInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaDBInfoAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaDBTableListResult> GetMetaDBTableListOutcome;
+			typedef std::future<GetMetaDBTableListOutcome> GetMetaDBTableListOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaDBTableListRequest&, const GetMetaDBTableListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaDBTableListAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaTableBasicInfoResult> GetMetaTableBasicInfoOutcome;
+			typedef std::future<GetMetaTableBasicInfoOutcome> GetMetaTableBasicInfoOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaTableBasicInfoRequest&, const GetMetaTableBasicInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaTableBasicInfoAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaTableChangeLogResult> GetMetaTableChangeLogOutcome;
+			typedef std::future<GetMetaTableChangeLogOutcome> GetMetaTableChangeLogOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaTableChangeLogRequest&, const GetMetaTableChangeLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaTableChangeLogAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaTableColumnResult> GetMetaTableColumnOutcome;
+			typedef std::future<GetMetaTableColumnOutcome> GetMetaTableColumnOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaTableColumnRequest&, const GetMetaTableColumnOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaTableColumnAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaTableFullInfoResult> GetMetaTableFullInfoOutcome;
+			typedef std::future<GetMetaTableFullInfoOutcome> GetMetaTableFullInfoOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaTableFullInfoRequest&, const GetMetaTableFullInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaTableFullInfoAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaTableIntroWikiResult> GetMetaTableIntroWikiOutcome;
+			typedef std::future<GetMetaTableIntroWikiOutcome> GetMetaTableIntroWikiOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaTableIntroWikiRequest&, const GetMetaTableIntroWikiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaTableIntroWikiAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaTableLineageResult> GetMetaTableLineageOutcome;
+			typedef std::future<GetMetaTableLineageOutcome> GetMetaTableLineageOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaTableLineageRequest&, const GetMetaTableLineageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaTableLineageAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaTableListByCategoryResult> GetMetaTableListByCategoryOutcome;
+			typedef std::future<GetMetaTableListByCategoryOutcome> GetMetaTableListByCategoryOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaTableListByCategoryRequest&, const GetMetaTableListByCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaTableListByCategoryAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaTableOutputResult> GetMetaTableOutputOutcome;
+			typedef std::future<GetMetaTableOutputOutcome> GetMetaTableOutputOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaTableOutputRequest&, const GetMetaTableOutputOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaTableOutputAsyncHandler;
+			typedef Outcome<Error, Model::GetMetaTablePartitionResult> GetMetaTablePartitionOutcome;
+			typedef std::future<GetMetaTablePartitionOutcome> GetMetaTablePartitionOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaTablePartitionRequest&, const GetMetaTablePartitionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaTablePartitionAsyncHandler;
+			typedef Outcome<Error, Model::GetNodeResult> GetNodeOutcome;
+			typedef std::future<GetNodeOutcome> GetNodeOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetNodeRequest&, const GetNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNodeAsyncHandler;
+			typedef Outcome<Error, Model::GetNodeCodeResult> GetNodeCodeOutcome;
+			typedef std::future<GetNodeCodeOutcome> GetNodeCodeOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetNodeCodeRequest&, const GetNodeCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNodeCodeAsyncHandler;
+			typedef Outcome<Error, Model::GetNodeOnBaselineResult> GetNodeOnBaselineOutcome;
+			typedef std::future<GetNodeOnBaselineOutcome> GetNodeOnBaselineOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetNodeOnBaselineRequest&, const GetNodeOnBaselineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNodeOnBaselineAsyncHandler;
+			typedef Outcome<Error, Model::GetProjectDetailResult> GetProjectDetailOutcome;
+			typedef std::future<GetProjectDetailOutcome> GetProjectDetailOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetProjectDetailRequest&, const GetProjectDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetProjectDetailAsyncHandler;
+			typedef Outcome<Error, Model::GetQualityEntityResult> GetQualityEntityOutcome;
+			typedef std::future<GetQualityEntityOutcome> GetQualityEntityOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetQualityEntityRequest&, const GetQualityEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetQualityEntityAsyncHandler;
+			typedef Outcome<Error, Model::GetQualityFollowerResult> GetQualityFollowerOutcome;
+			typedef std::future<GetQualityFollowerOutcome> GetQualityFollowerOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetQualityFollowerRequest&, const GetQualityFollowerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetQualityFollowerAsyncHandler;
+			typedef Outcome<Error, Model::GetQualityRuleResult> GetQualityRuleOutcome;
+			typedef std::future<GetQualityRuleOutcome> GetQualityRuleOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetQualityRuleRequest&, const GetQualityRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetQualityRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetRemindResult> GetRemindOutcome;
+			typedef std::future<GetRemindOutcome> GetRemindOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetRemindRequest&, const GetRemindOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRemindAsyncHandler;
+			typedef Outcome<Error, Model::GetTopicResult> GetTopicOutcome;
+			typedef std::future<GetTopicOutcome> GetTopicOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetTopicRequest&, const GetTopicOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTopicAsyncHandler;
+			typedef Outcome<Error, Model::GetTopicInfluenceResult> GetTopicInfluenceOutcome;
+			typedef std::future<GetTopicInfluenceOutcome> GetTopicInfluenceOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetTopicInfluenceRequest&, const GetTopicInfluenceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTopicInfluenceAsyncHandler;
+			typedef Outcome<Error, Model::ListAlertMessagesResult> ListAlertMessagesOutcome;
+			typedef std::future<ListAlertMessagesOutcome> ListAlertMessagesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListAlertMessagesRequest&, const ListAlertMessagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAlertMessagesAsyncHandler;
+			typedef Outcome<Error, Model::ListBaselineConfigsResult> ListBaselineConfigsOutcome;
+			typedef std::future<ListBaselineConfigsOutcome> ListBaselineConfigsOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListBaselineConfigsRequest&, const ListBaselineConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListBaselineConfigsAsyncHandler;
+			typedef Outcome<Error, Model::ListBaselineStatusesResult> ListBaselineStatusesOutcome;
+			typedef std::future<ListBaselineStatusesOutcome> ListBaselineStatusesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListBaselineStatusesRequest&, const ListBaselineStatusesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListBaselineStatusesAsyncHandler;
+			typedef Outcome<Error, Model::ListBusinessResult> ListBusinessOutcome;
+			typedef std::future<ListBusinessOutcome> ListBusinessOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListBusinessRequest&, const ListBusinessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListBusinessAsyncHandler;
+			typedef Outcome<Error, Model::ListCalcEnginesResult> ListCalcEnginesOutcome;
+			typedef std::future<ListCalcEnginesOutcome> ListCalcEnginesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListCalcEnginesRequest&, const ListCalcEnginesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCalcEnginesAsyncHandler;
+			typedef Outcome<Error, Model::ListConnectionsResult> ListConnectionsOutcome;
+			typedef std::future<ListConnectionsOutcome> ListConnectionsOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListConnectionsRequest&, const ListConnectionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListConnectionsAsyncHandler;
+			typedef Outcome<Error, Model::ListDataServiceApiAuthoritiesResult> ListDataServiceApiAuthoritiesOutcome;
+			typedef std::future<ListDataServiceApiAuthoritiesOutcome> ListDataServiceApiAuthoritiesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDataServiceApiAuthoritiesRequest&, const ListDataServiceApiAuthoritiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataServiceApiAuthoritiesAsyncHandler;
+			typedef Outcome<Error, Model::ListDataServiceApisResult> ListDataServiceApisOutcome;
+			typedef std::future<ListDataServiceApisOutcome> ListDataServiceApisOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDataServiceApisRequest&, const ListDataServiceApisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataServiceApisAsyncHandler;
+			typedef Outcome<Error, Model::ListDataServiceApplicationsResult> ListDataServiceApplicationsOutcome;
+			typedef std::future<ListDataServiceApplicationsOutcome> ListDataServiceApplicationsOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDataServiceApplicationsRequest&, const ListDataServiceApplicationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataServiceApplicationsAsyncHandler;
+			typedef Outcome<Error, Model::ListDataServiceAuthorizedApisResult> ListDataServiceAuthorizedApisOutcome;
+			typedef std::future<ListDataServiceAuthorizedApisOutcome> ListDataServiceAuthorizedApisOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDataServiceAuthorizedApisRequest&, const ListDataServiceAuthorizedApisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataServiceAuthorizedApisAsyncHandler;
+			typedef Outcome<Error, Model::ListDataServicePublishedApisResult> ListDataServicePublishedApisOutcome;
+			typedef std::future<ListDataServicePublishedApisOutcome> ListDataServicePublishedApisOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDataServicePublishedApisRequest&, const ListDataServicePublishedApisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataServicePublishedApisAsyncHandler;
+			typedef Outcome<Error, Model::ListFileVersionsResult> ListFileVersionsOutcome;
+			typedef std::future<ListFileVersionsOutcome> ListFileVersionsOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListFileVersionsRequest&, const ListFileVersionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFileVersionsAsyncHandler;
+			typedef Outcome<Error, Model::ListFilesResult> ListFilesOutcome;
+			typedef std::future<ListFilesOutcome> ListFilesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListFilesRequest&, const ListFilesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFilesAsyncHandler;
+			typedef Outcome<Error, Model::ListFoldersResult> ListFoldersOutcome;
+			typedef std::future<ListFoldersOutcome> ListFoldersOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListFoldersRequest&, const ListFoldersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFoldersAsyncHandler;
+			typedef Outcome<Error, Model::ListInstancesResult> ListInstancesOutcome;
+			typedef std::future<ListInstancesOutcome> ListInstancesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListInstancesRequest&, const ListInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesAsyncHandler;
+			typedef Outcome<Error, Model::ListNodeIOResult> ListNodeIOOutcome;
+			typedef std::future<ListNodeIOOutcome> ListNodeIOOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListNodeIORequest&, const ListNodeIOOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNodeIOAsyncHandler;
+			typedef Outcome<Error, Model::ListNodesResult> ListNodesOutcome;
+			typedef std::future<ListNodesOutcome> ListNodesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListNodesRequest&, const ListNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNodesAsyncHandler;
+			typedef Outcome<Error, Model::ListQualityRulesResult> ListQualityRulesOutcome;
+			typedef std::future<ListQualityRulesOutcome> ListQualityRulesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListQualityRulesRequest&, const ListQualityRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListQualityRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListRemindsResult> ListRemindsOutcome;
+			typedef std::future<ListRemindsOutcome> ListRemindsOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListRemindsRequest&, const ListRemindsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRemindsAsyncHandler;
+			typedef Outcome<Error, Model::ListResourceGroupsResult> ListResourceGroupsOutcome;
+			typedef std::future<ListResourceGroupsOutcome> ListResourceGroupsOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListResourceGroupsRequest&, const ListResourceGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ListTopicsResult> ListTopicsOutcome;
+			typedef std::future<ListTopicsOutcome> ListTopicsOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListTopicsRequest&, const ListTopicsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTopicsAsyncHandler;
+			typedef Outcome<Error, Model::PublishDataServiceApiResult> PublishDataServiceApiOutcome;
+			typedef std::future<PublishDataServiceApiOutcome> PublishDataServiceApiOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::PublishDataServiceApiRequest&, const PublishDataServiceApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PublishDataServiceApiAsyncHandler;
+			typedef Outcome<Error, Model::RestartInstanceResult> RestartInstanceOutcome;
+			typedef std::future<RestartInstanceOutcome> RestartInstanceOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::RestartInstanceRequest&, const RestartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartInstanceAsyncHandler;
+			typedef Outcome<Error, Model::ResumeInstanceResult> ResumeInstanceOutcome;
+			typedef std::future<ResumeInstanceOutcome> ResumeInstanceOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ResumeInstanceRequest&, const ResumeInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResumeInstanceAsyncHandler;
+			typedef Outcome<Error, Model::SearchMetaTablesResult> SearchMetaTablesOutcome;
+			typedef std::future<SearchMetaTablesOutcome> SearchMetaTablesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::SearchMetaTablesRequest&, const SearchMetaTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchMetaTablesAsyncHandler;
+			typedef Outcome<Error, Model::SetSuccessInstanceResult> SetSuccessInstanceOutcome;
+			typedef std::future<SetSuccessInstanceOutcome> SetSuccessInstanceOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::SetSuccessInstanceRequest&, const SetSuccessInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetSuccessInstanceAsyncHandler;
+			typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
+			typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
+			typedef Outcome<Error, Model::SubmitFileResult> SubmitFileOutcome;
+			typedef std::future<SubmitFileOutcome> SubmitFileOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::SubmitFileRequest&, const SubmitFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitFileAsyncHandler;
+			typedef Outcome<Error, Model::SuspendInstanceResult> SuspendInstanceOutcome;
+			typedef std::future<SuspendInstanceOutcome> SuspendInstanceOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::SuspendInstanceRequest&, const SuspendInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SuspendInstanceAsyncHandler;
+			typedef Outcome<Error, Model::UpdateBusinessResult> UpdateBusinessOutcome;
+			typedef std::future<UpdateBusinessOutcome> UpdateBusinessOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateBusinessRequest&, const UpdateBusinessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateBusinessAsyncHandler;
+			typedef Outcome<Error, Model::UpdateConnectionResult> UpdateConnectionOutcome;
+			typedef std::future<UpdateConnectionOutcome> UpdateConnectionOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateConnectionRequest&, const UpdateConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateConnectionAsyncHandler;
+			typedef Outcome<Error, Model::UpdateDataServiceApiResult> UpdateDataServiceApiOutcome;
+			typedef std::future<UpdateDataServiceApiOutcome> UpdateDataServiceApiOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateDataServiceApiRequest&, const UpdateDataServiceApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDataServiceApiAsyncHandler;
+			typedef Outcome<Error, Model::UpdateFileResult> UpdateFileOutcome;
+			typedef std::future<UpdateFileOutcome> UpdateFileOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateFileRequest&, const UpdateFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFileAsyncHandler;
+			typedef Outcome<Error, Model::UpdateFolderResult> UpdateFolderOutcome;
+			typedef std::future<UpdateFolderOutcome> UpdateFolderOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateFolderRequest&, const UpdateFolderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFolderAsyncHandler;
+			typedef Outcome<Error, Model::UpdateMetaCategoryResult> UpdateMetaCategoryOutcome;
+			typedef std::future<UpdateMetaCategoryOutcome> UpdateMetaCategoryOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateMetaCategoryRequest&, const UpdateMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMetaCategoryAsyncHandler;
+			typedef Outcome<Error, Model::UpdateQualityFollowerResult> UpdateQualityFollowerOutcome;
+			typedef std::future<UpdateQualityFollowerOutcome> UpdateQualityFollowerOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateQualityFollowerRequest&, const UpdateQualityFollowerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateQualityFollowerAsyncHandler;
+			typedef Outcome<Error, Model::UpdateQualityRuleResult> UpdateQualityRuleOutcome;
+			typedef std::future<UpdateQualityRuleOutcome> UpdateQualityRuleOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateQualityRuleRequest&, const UpdateQualityRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateQualityRuleAsyncHandler;
+			typedef Outcome<Error, Model::UpdateRemindResult> UpdateRemindOutcome;
+			typedef std::future<UpdateRemindOutcome> UpdateRemindOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateRemindRequest&, const UpdateRemindOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateRemindAsyncHandler;
+			typedef Outcome<Error, Model::UpdateUdfFileResult> UpdateUdfFileOutcome;
+			typedef std::future<UpdateUdfFileOutcome> UpdateUdfFileOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateUdfFileRequest&, const UpdateUdfFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateUdfFileAsyncHandler;
+
+			Dataworks_publicClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			Dataworks_publicClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			Dataworks_publicClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~Dataworks_publicClient();
+			AbolishDataServiceApiOutcome abolishDataServiceApi(const Model::AbolishDataServiceApiRequest &request)const;
+			void abolishDataServiceApiAsync(const Model::AbolishDataServiceApiRequest& request, const AbolishDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AbolishDataServiceApiOutcomeCallable abolishDataServiceApiCallable(const Model::AbolishDataServiceApiRequest& request) const;
+			AddToMetaCategoryOutcome addToMetaCategory(const Model::AddToMetaCategoryRequest &request)const;
+			void addToMetaCategoryAsync(const Model::AddToMetaCategoryRequest& request, const AddToMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddToMetaCategoryOutcomeCallable addToMetaCategoryCallable(const Model::AddToMetaCategoryRequest& request) const;
+			CheckMetaPartitionOutcome checkMetaPartition(const Model::CheckMetaPartitionRequest &request)const;
+			void checkMetaPartitionAsync(const Model::CheckMetaPartitionRequest& request, const CheckMetaPartitionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckMetaPartitionOutcomeCallable checkMetaPartitionCallable(const Model::CheckMetaPartitionRequest& request) const;
+			CheckMetaTableOutcome checkMetaTable(const Model::CheckMetaTableRequest &request)const;
+			void checkMetaTableAsync(const Model::CheckMetaTableRequest& request, const CheckMetaTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckMetaTableOutcomeCallable checkMetaTableCallable(const Model::CheckMetaTableRequest& request) const;
+			CreateConnectionOutcome createConnection(const Model::CreateConnectionRequest &request)const;
+			void createConnectionAsync(const Model::CreateConnectionRequest& request, const CreateConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateConnectionOutcomeCallable createConnectionCallable(const Model::CreateConnectionRequest& request) const;
+			CreateDataServiceApiOutcome createDataServiceApi(const Model::CreateDataServiceApiRequest &request)const;
+			void createDataServiceApiAsync(const Model::CreateDataServiceApiRequest& request, const CreateDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDataServiceApiOutcomeCallable createDataServiceApiCallable(const Model::CreateDataServiceApiRequest& request) const;
+			CreateFileOutcome createFile(const Model::CreateFileRequest &request)const;
+			void createFileAsync(const Model::CreateFileRequest& request, const CreateFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateFileOutcomeCallable createFileCallable(const Model::CreateFileRequest& request) const;
+			CreateFolderOutcome createFolder(const Model::CreateFolderRequest &request)const;
+			void createFolderAsync(const Model::CreateFolderRequest& request, const CreateFolderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateFolderOutcomeCallable createFolderCallable(const Model::CreateFolderRequest& request) const;
+			CreateMetaCategoryOutcome createMetaCategory(const Model::CreateMetaCategoryRequest &request)const;
+			void createMetaCategoryAsync(const Model::CreateMetaCategoryRequest& request, const CreateMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateMetaCategoryOutcomeCallable createMetaCategoryCallable(const Model::CreateMetaCategoryRequest& request) const;
+			CreateNodeComplementOutcome createNodeComplement(const Model::CreateNodeComplementRequest &request)const;
+			void createNodeComplementAsync(const Model::CreateNodeComplementRequest& request, const CreateNodeComplementAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateNodeComplementOutcomeCallable createNodeComplementCallable(const Model::CreateNodeComplementRequest& request) const;
+			CreateNodeTestOutcome createNodeTest(const Model::CreateNodeTestRequest &request)const;
+			void createNodeTestAsync(const Model::CreateNodeTestRequest& request, const CreateNodeTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateNodeTestOutcomeCallable createNodeTestCallable(const Model::CreateNodeTestRequest& request) const;
+			CreateQualityEntityOutcome createQualityEntity(const Model::CreateQualityEntityRequest &request)const;
+			void createQualityEntityAsync(const Model::CreateQualityEntityRequest& request, const CreateQualityEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateQualityEntityOutcomeCallable createQualityEntityCallable(const Model::CreateQualityEntityRequest& request) const;
+			CreateQualityFollowerOutcome createQualityFollower(const Model::CreateQualityFollowerRequest &request)const;
+			void createQualityFollowerAsync(const Model::CreateQualityFollowerRequest& request, const CreateQualityFollowerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateQualityFollowerOutcomeCallable createQualityFollowerCallable(const Model::CreateQualityFollowerRequest& request) const;
+			CreateQualityRelativeNodeOutcome createQualityRelativeNode(const Model::CreateQualityRelativeNodeRequest &request)const;
+			void createQualityRelativeNodeAsync(const Model::CreateQualityRelativeNodeRequest& request, const CreateQualityRelativeNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateQualityRelativeNodeOutcomeCallable createQualityRelativeNodeCallable(const Model::CreateQualityRelativeNodeRequest& request) const;
+			CreateQualityRuleOutcome createQualityRule(const Model::CreateQualityRuleRequest &request)const;
+			void createQualityRuleAsync(const Model::CreateQualityRuleRequest& request, const CreateQualityRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateQualityRuleOutcomeCallable createQualityRuleCallable(const Model::CreateQualityRuleRequest& request) const;
+			CreateRemindOutcome createRemind(const Model::CreateRemindRequest &request)const;
+			void createRemindAsync(const Model::CreateRemindRequest& request, const CreateRemindAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateRemindOutcomeCallable createRemindCallable(const Model::CreateRemindRequest& request) const;
+			CreateUdfFileOutcome createUdfFile(const Model::CreateUdfFileRequest &request)const;
+			void createUdfFileAsync(const Model::CreateUdfFileRequest& request, const CreateUdfFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateUdfFileOutcomeCallable createUdfFileCallable(const Model::CreateUdfFileRequest& request) const;
+			DeleteBusinessOutcome deleteBusiness(const Model::DeleteBusinessRequest &request)const;
+			void deleteBusinessAsync(const Model::DeleteBusinessRequest& request, const DeleteBusinessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteBusinessOutcomeCallable deleteBusinessCallable(const Model::DeleteBusinessRequest& request) const;
+			DeleteConnectionOutcome deleteConnection(const Model::DeleteConnectionRequest &request)const;
+			void deleteConnectionAsync(const Model::DeleteConnectionRequest& request, const DeleteConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteConnectionOutcomeCallable deleteConnectionCallable(const Model::DeleteConnectionRequest& request) const;
+			DeleteDataServiceApiOutcome deleteDataServiceApi(const Model::DeleteDataServiceApiRequest &request)const;
+			void deleteDataServiceApiAsync(const Model::DeleteDataServiceApiRequest& request, const DeleteDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteDataServiceApiOutcomeCallable deleteDataServiceApiCallable(const Model::DeleteDataServiceApiRequest& request) const;
+			DeleteFileOutcome deleteFile(const Model::DeleteFileRequest &request)const;
+			void deleteFileAsync(const Model::DeleteFileRequest& request, const DeleteFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFileOutcomeCallable deleteFileCallable(const Model::DeleteFileRequest& request) const;
+			DeleteFolderOutcome deleteFolder(const Model::DeleteFolderRequest &request)const;
+			void deleteFolderAsync(const Model::DeleteFolderRequest& request, const DeleteFolderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFolderOutcomeCallable deleteFolderCallable(const Model::DeleteFolderRequest& request) const;
+			DeleteFromMetaCategoryOutcome deleteFromMetaCategory(const Model::DeleteFromMetaCategoryRequest &request)const;
+			void deleteFromMetaCategoryAsync(const Model::DeleteFromMetaCategoryRequest& request, const DeleteFromMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFromMetaCategoryOutcomeCallable deleteFromMetaCategoryCallable(const Model::DeleteFromMetaCategoryRequest& request) const;
+			DeleteMetaCategoryOutcome deleteMetaCategory(const Model::DeleteMetaCategoryRequest &request)const;
+			void deleteMetaCategoryAsync(const Model::DeleteMetaCategoryRequest& request, const DeleteMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteMetaCategoryOutcomeCallable deleteMetaCategoryCallable(const Model::DeleteMetaCategoryRequest& request) const;
+			DeleteQualityEntityOutcome deleteQualityEntity(const Model::DeleteQualityEntityRequest &request)const;
+			void deleteQualityEntityAsync(const Model::DeleteQualityEntityRequest& request, const DeleteQualityEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteQualityEntityOutcomeCallable deleteQualityEntityCallable(const Model::DeleteQualityEntityRequest& request) const;
+			DeleteQualityFollowerOutcome deleteQualityFollower(const Model::DeleteQualityFollowerRequest &request)const;
+			void deleteQualityFollowerAsync(const Model::DeleteQualityFollowerRequest& request, const DeleteQualityFollowerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteQualityFollowerOutcomeCallable deleteQualityFollowerCallable(const Model::DeleteQualityFollowerRequest& request) const;
+			DeleteQualityRelativeNodeOutcome deleteQualityRelativeNode(const Model::DeleteQualityRelativeNodeRequest &request)const;
+			void deleteQualityRelativeNodeAsync(const Model::DeleteQualityRelativeNodeRequest& request, const DeleteQualityRelativeNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteQualityRelativeNodeOutcomeCallable deleteQualityRelativeNodeCallable(const Model::DeleteQualityRelativeNodeRequest& request) const;
+			DeleteQualityRuleOutcome deleteQualityRule(const Model::DeleteQualityRuleRequest &request)const;
+			void deleteQualityRuleAsync(const Model::DeleteQualityRuleRequest& request, const DeleteQualityRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteQualityRuleOutcomeCallable deleteQualityRuleCallable(const Model::DeleteQualityRuleRequest& request) const;
+			DeleteRemindOutcome deleteRemind(const Model::DeleteRemindRequest &request)const;
+			void deleteRemindAsync(const Model::DeleteRemindRequest& request, const DeleteRemindAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteRemindOutcomeCallable deleteRemindCallable(const Model::DeleteRemindRequest& request) const;
+			DeployFileOutcome deployFile(const Model::DeployFileRequest &request)const;
+			void deployFileAsync(const Model::DeployFileRequest& request, const DeployFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeployFileOutcomeCallable deployFileCallable(const Model::DeployFileRequest& request) const;
+			EstablishRelationTableToBusinessOutcome establishRelationTableToBusiness(const Model::EstablishRelationTableToBusinessRequest &request)const;
+			void establishRelationTableToBusinessAsync(const Model::EstablishRelationTableToBusinessRequest& request, const EstablishRelationTableToBusinessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EstablishRelationTableToBusinessOutcomeCallable establishRelationTableToBusinessCallable(const Model::EstablishRelationTableToBusinessRequest& request) const;
+			GetBaselineConfigOutcome getBaselineConfig(const Model::GetBaselineConfigRequest &request)const;
+			void getBaselineConfigAsync(const Model::GetBaselineConfigRequest& request, const GetBaselineConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetBaselineConfigOutcomeCallable getBaselineConfigCallable(const Model::GetBaselineConfigRequest& request) const;
+			GetBaselineKeyPathOutcome getBaselineKeyPath(const Model::GetBaselineKeyPathRequest &request)const;
+			void getBaselineKeyPathAsync(const Model::GetBaselineKeyPathRequest& request, const GetBaselineKeyPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetBaselineKeyPathOutcomeCallable getBaselineKeyPathCallable(const Model::GetBaselineKeyPathRequest& request) const;
+			GetBaselineStatusOutcome getBaselineStatus(const Model::GetBaselineStatusRequest &request)const;
+			void getBaselineStatusAsync(const Model::GetBaselineStatusRequest& request, const GetBaselineStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetBaselineStatusOutcomeCallable getBaselineStatusCallable(const Model::GetBaselineStatusRequest& request) const;
+			GetBusinessOutcome getBusiness(const Model::GetBusinessRequest &request)const;
+			void getBusinessAsync(const Model::GetBusinessRequest& request, const GetBusinessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetBusinessOutcomeCallable getBusinessCallable(const Model::GetBusinessRequest& request) const;
+			GetDataServiceApiOutcome getDataServiceApi(const Model::GetDataServiceApiRequest &request)const;
+			void getDataServiceApiAsync(const Model::GetDataServiceApiRequest& request, const GetDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDataServiceApiOutcomeCallable getDataServiceApiCallable(const Model::GetDataServiceApiRequest& request) const;
+			GetDataServiceApplicationOutcome getDataServiceApplication(const Model::GetDataServiceApplicationRequest &request)const;
+			void getDataServiceApplicationAsync(const Model::GetDataServiceApplicationRequest& request, const GetDataServiceApplicationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDataServiceApplicationOutcomeCallable getDataServiceApplicationCallable(const Model::GetDataServiceApplicationRequest& request) const;
+			GetDataServicePublishedApiOutcome getDataServicePublishedApi(const Model::GetDataServicePublishedApiRequest &request)const;
+			void getDataServicePublishedApiAsync(const Model::GetDataServicePublishedApiRequest& request, const GetDataServicePublishedApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDataServicePublishedApiOutcomeCallable getDataServicePublishedApiCallable(const Model::GetDataServicePublishedApiRequest& request) const;
+			GetDeploymentOutcome getDeployment(const Model::GetDeploymentRequest &request)const;
+			void getDeploymentAsync(const Model::GetDeploymentRequest& request, const GetDeploymentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDeploymentOutcomeCallable getDeploymentCallable(const Model::GetDeploymentRequest& request) const;
+			GetFileOutcome getFile(const Model::GetFileRequest &request)const;
+			void getFileAsync(const Model::GetFileRequest& request, const GetFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFileOutcomeCallable getFileCallable(const Model::GetFileRequest& request) const;
+			GetFileVersionOutcome getFileVersion(const Model::GetFileVersionRequest &request)const;
+			void getFileVersionAsync(const Model::GetFileVersionRequest& request, const GetFileVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFileVersionOutcomeCallable getFileVersionCallable(const Model::GetFileVersionRequest& request) const;
+			GetFolderOutcome getFolder(const Model::GetFolderRequest &request)const;
+			void getFolderAsync(const Model::GetFolderRequest& request, const GetFolderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFolderOutcomeCallable getFolderCallable(const Model::GetFolderRequest& request) const;
+			GetInstanceOutcome getInstance(const Model::GetInstanceRequest &request)const;
+			void getInstanceAsync(const Model::GetInstanceRequest& request, const GetInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetInstanceOutcomeCallable getInstanceCallable(const Model::GetInstanceRequest& request) const;
+			GetInstanceLogOutcome getInstanceLog(const Model::GetInstanceLogRequest &request)const;
+			void getInstanceLogAsync(const Model::GetInstanceLogRequest& request, const GetInstanceLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetInstanceLogOutcomeCallable getInstanceLogCallable(const Model::GetInstanceLogRequest& request) const;
+			GetMetaCategoryOutcome getMetaCategory(const Model::GetMetaCategoryRequest &request)const;
+			void getMetaCategoryAsync(const Model::GetMetaCategoryRequest& request, const GetMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaCategoryOutcomeCallable getMetaCategoryCallable(const Model::GetMetaCategoryRequest& request) const;
+			GetMetaColumnLineageOutcome getMetaColumnLineage(const Model::GetMetaColumnLineageRequest &request)const;
+			void getMetaColumnLineageAsync(const Model::GetMetaColumnLineageRequest& request, const GetMetaColumnLineageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaColumnLineageOutcomeCallable getMetaColumnLineageCallable(const Model::GetMetaColumnLineageRequest& request) const;
+			GetMetaDBInfoOutcome getMetaDBInfo(const Model::GetMetaDBInfoRequest &request)const;
+			void getMetaDBInfoAsync(const Model::GetMetaDBInfoRequest& request, const GetMetaDBInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaDBInfoOutcomeCallable getMetaDBInfoCallable(const Model::GetMetaDBInfoRequest& request) const;
+			GetMetaDBTableListOutcome getMetaDBTableList(const Model::GetMetaDBTableListRequest &request)const;
+			void getMetaDBTableListAsync(const Model::GetMetaDBTableListRequest& request, const GetMetaDBTableListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaDBTableListOutcomeCallable getMetaDBTableListCallable(const Model::GetMetaDBTableListRequest& request) const;
+			GetMetaTableBasicInfoOutcome getMetaTableBasicInfo(const Model::GetMetaTableBasicInfoRequest &request)const;
+			void getMetaTableBasicInfoAsync(const Model::GetMetaTableBasicInfoRequest& request, const GetMetaTableBasicInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaTableBasicInfoOutcomeCallable getMetaTableBasicInfoCallable(const Model::GetMetaTableBasicInfoRequest& request) const;
+			GetMetaTableChangeLogOutcome getMetaTableChangeLog(const Model::GetMetaTableChangeLogRequest &request)const;
+			void getMetaTableChangeLogAsync(const Model::GetMetaTableChangeLogRequest& request, const GetMetaTableChangeLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaTableChangeLogOutcomeCallable getMetaTableChangeLogCallable(const Model::GetMetaTableChangeLogRequest& request) const;
+			GetMetaTableColumnOutcome getMetaTableColumn(const Model::GetMetaTableColumnRequest &request)const;
+			void getMetaTableColumnAsync(const Model::GetMetaTableColumnRequest& request, const GetMetaTableColumnAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaTableColumnOutcomeCallable getMetaTableColumnCallable(const Model::GetMetaTableColumnRequest& request) const;
+			GetMetaTableFullInfoOutcome getMetaTableFullInfo(const Model::GetMetaTableFullInfoRequest &request)const;
+			void getMetaTableFullInfoAsync(const Model::GetMetaTableFullInfoRequest& request, const GetMetaTableFullInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaTableFullInfoOutcomeCallable getMetaTableFullInfoCallable(const Model::GetMetaTableFullInfoRequest& request) const;
+			GetMetaTableIntroWikiOutcome getMetaTableIntroWiki(const Model::GetMetaTableIntroWikiRequest &request)const;
+			void getMetaTableIntroWikiAsync(const Model::GetMetaTableIntroWikiRequest& request, const GetMetaTableIntroWikiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaTableIntroWikiOutcomeCallable getMetaTableIntroWikiCallable(const Model::GetMetaTableIntroWikiRequest& request) const;
+			GetMetaTableLineageOutcome getMetaTableLineage(const Model::GetMetaTableLineageRequest &request)const;
+			void getMetaTableLineageAsync(const Model::GetMetaTableLineageRequest& request, const GetMetaTableLineageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaTableLineageOutcomeCallable getMetaTableLineageCallable(const Model::GetMetaTableLineageRequest& request) const;
+			GetMetaTableListByCategoryOutcome getMetaTableListByCategory(const Model::GetMetaTableListByCategoryRequest &request)const;
+			void getMetaTableListByCategoryAsync(const Model::GetMetaTableListByCategoryRequest& request, const GetMetaTableListByCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaTableListByCategoryOutcomeCallable getMetaTableListByCategoryCallable(const Model::GetMetaTableListByCategoryRequest& request) const;
+			GetMetaTableOutputOutcome getMetaTableOutput(const Model::GetMetaTableOutputRequest &request)const;
+			void getMetaTableOutputAsync(const Model::GetMetaTableOutputRequest& request, const GetMetaTableOutputAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaTableOutputOutcomeCallable getMetaTableOutputCallable(const Model::GetMetaTableOutputRequest& request) const;
+			GetMetaTablePartitionOutcome getMetaTablePartition(const Model::GetMetaTablePartitionRequest &request)const;
+			void getMetaTablePartitionAsync(const Model::GetMetaTablePartitionRequest& request, const GetMetaTablePartitionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMetaTablePartitionOutcomeCallable getMetaTablePartitionCallable(const Model::GetMetaTablePartitionRequest& request) const;
+			GetNodeOutcome getNode(const Model::GetNodeRequest &request)const;
+			void getNodeAsync(const Model::GetNodeRequest& request, const GetNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNodeOutcomeCallable getNodeCallable(const Model::GetNodeRequest& request) const;
+			GetNodeCodeOutcome getNodeCode(const Model::GetNodeCodeRequest &request)const;
+			void getNodeCodeAsync(const Model::GetNodeCodeRequest& request, const GetNodeCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNodeCodeOutcomeCallable getNodeCodeCallable(const Model::GetNodeCodeRequest& request) const;
+			GetNodeOnBaselineOutcome getNodeOnBaseline(const Model::GetNodeOnBaselineRequest &request)const;
+			void getNodeOnBaselineAsync(const Model::GetNodeOnBaselineRequest& request, const GetNodeOnBaselineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNodeOnBaselineOutcomeCallable getNodeOnBaselineCallable(const Model::GetNodeOnBaselineRequest& request) const;
+			GetProjectDetailOutcome getProjectDetail(const Model::GetProjectDetailRequest &request)const;
+			void getProjectDetailAsync(const Model::GetProjectDetailRequest& request, const GetProjectDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetProjectDetailOutcomeCallable getProjectDetailCallable(const Model::GetProjectDetailRequest& request) const;
+			GetQualityEntityOutcome getQualityEntity(const Model::GetQualityEntityRequest &request)const;
+			void getQualityEntityAsync(const Model::GetQualityEntityRequest& request, const GetQualityEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetQualityEntityOutcomeCallable getQualityEntityCallable(const Model::GetQualityEntityRequest& request) const;
+			GetQualityFollowerOutcome getQualityFollower(const Model::GetQualityFollowerRequest &request)const;
+			void getQualityFollowerAsync(const Model::GetQualityFollowerRequest& request, const GetQualityFollowerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetQualityFollowerOutcomeCallable getQualityFollowerCallable(const Model::GetQualityFollowerRequest& request) const;
+			GetQualityRuleOutcome getQualityRule(const Model::GetQualityRuleRequest &request)const;
+			void getQualityRuleAsync(const Model::GetQualityRuleRequest& request, const GetQualityRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetQualityRuleOutcomeCallable getQualityRuleCallable(const Model::GetQualityRuleRequest& request) const;
+			GetRemindOutcome getRemind(const Model::GetRemindRequest &request)const;
+			void getRemindAsync(const Model::GetRemindRequest& request, const GetRemindAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetRemindOutcomeCallable getRemindCallable(const Model::GetRemindRequest& request) const;
+			GetTopicOutcome getTopic(const Model::GetTopicRequest &request)const;
+			void getTopicAsync(const Model::GetTopicRequest& request, const GetTopicAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTopicOutcomeCallable getTopicCallable(const Model::GetTopicRequest& request) const;
+			GetTopicInfluenceOutcome getTopicInfluence(const Model::GetTopicInfluenceRequest &request)const;
+			void getTopicInfluenceAsync(const Model::GetTopicInfluenceRequest& request, const GetTopicInfluenceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTopicInfluenceOutcomeCallable getTopicInfluenceCallable(const Model::GetTopicInfluenceRequest& request) const;
+			ListAlertMessagesOutcome listAlertMessages(const Model::ListAlertMessagesRequest &request)const;
+			void listAlertMessagesAsync(const Model::ListAlertMessagesRequest& request, const ListAlertMessagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAlertMessagesOutcomeCallable listAlertMessagesCallable(const Model::ListAlertMessagesRequest& request) const;
+			ListBaselineConfigsOutcome listBaselineConfigs(const Model::ListBaselineConfigsRequest &request)const;
+			void listBaselineConfigsAsync(const Model::ListBaselineConfigsRequest& request, const ListBaselineConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListBaselineConfigsOutcomeCallable listBaselineConfigsCallable(const Model::ListBaselineConfigsRequest& request) const;
+			ListBaselineStatusesOutcome listBaselineStatuses(const Model::ListBaselineStatusesRequest &request)const;
+			void listBaselineStatusesAsync(const Model::ListBaselineStatusesRequest& request, const ListBaselineStatusesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListBaselineStatusesOutcomeCallable listBaselineStatusesCallable(const Model::ListBaselineStatusesRequest& request) const;
+			ListBusinessOutcome listBusiness(const Model::ListBusinessRequest &request)const;
+			void listBusinessAsync(const Model::ListBusinessRequest& request, const ListBusinessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListBusinessOutcomeCallable listBusinessCallable(const Model::ListBusinessRequest& request) const;
+			ListCalcEnginesOutcome listCalcEngines(const Model::ListCalcEnginesRequest &request)const;
+			void listCalcEnginesAsync(const Model::ListCalcEnginesRequest& request, const ListCalcEnginesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCalcEnginesOutcomeCallable listCalcEnginesCallable(const Model::ListCalcEnginesRequest& request) const;
+			ListConnectionsOutcome listConnections(const Model::ListConnectionsRequest &request)const;
+			void listConnectionsAsync(const Model::ListConnectionsRequest& request, const ListConnectionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListConnectionsOutcomeCallable listConnectionsCallable(const Model::ListConnectionsRequest& request) const;
+			ListDataServiceApiAuthoritiesOutcome listDataServiceApiAuthorities(const Model::ListDataServiceApiAuthoritiesRequest &request)const;
+			void listDataServiceApiAuthoritiesAsync(const Model::ListDataServiceApiAuthoritiesRequest& request, const ListDataServiceApiAuthoritiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDataServiceApiAuthoritiesOutcomeCallable listDataServiceApiAuthoritiesCallable(const Model::ListDataServiceApiAuthoritiesRequest& request) const;
+			ListDataServiceApisOutcome listDataServiceApis(const Model::ListDataServiceApisRequest &request)const;
+			void listDataServiceApisAsync(const Model::ListDataServiceApisRequest& request, const ListDataServiceApisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDataServiceApisOutcomeCallable listDataServiceApisCallable(const Model::ListDataServiceApisRequest& request) const;
+			ListDataServiceApplicationsOutcome listDataServiceApplications(const Model::ListDataServiceApplicationsRequest &request)const;
+			void listDataServiceApplicationsAsync(const Model::ListDataServiceApplicationsRequest& request, const ListDataServiceApplicationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDataServiceApplicationsOutcomeCallable listDataServiceApplicationsCallable(const Model::ListDataServiceApplicationsRequest& request) const;
+			ListDataServiceAuthorizedApisOutcome listDataServiceAuthorizedApis(const Model::ListDataServiceAuthorizedApisRequest &request)const;
+			void listDataServiceAuthorizedApisAsync(const Model::ListDataServiceAuthorizedApisRequest& request, const ListDataServiceAuthorizedApisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDataServiceAuthorizedApisOutcomeCallable listDataServiceAuthorizedApisCallable(const Model::ListDataServiceAuthorizedApisRequest& request) const;
+			ListDataServicePublishedApisOutcome listDataServicePublishedApis(const Model::ListDataServicePublishedApisRequest &request)const;
+			void listDataServicePublishedApisAsync(const Model::ListDataServicePublishedApisRequest& request, const ListDataServicePublishedApisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDataServicePublishedApisOutcomeCallable listDataServicePublishedApisCallable(const Model::ListDataServicePublishedApisRequest& request) const;
+			ListFileVersionsOutcome listFileVersions(const Model::ListFileVersionsRequest &request)const;
+			void listFileVersionsAsync(const Model::ListFileVersionsRequest& request, const ListFileVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFileVersionsOutcomeCallable listFileVersionsCallable(const Model::ListFileVersionsRequest& request) const;
+			ListFilesOutcome listFiles(const Model::ListFilesRequest &request)const;
+			void listFilesAsync(const Model::ListFilesRequest& request, const ListFilesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFilesOutcomeCallable listFilesCallable(const Model::ListFilesRequest& request) const;
+			ListFoldersOutcome listFolders(const Model::ListFoldersRequest &request)const;
+			void listFoldersAsync(const Model::ListFoldersRequest& request, const ListFoldersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFoldersOutcomeCallable listFoldersCallable(const Model::ListFoldersRequest& request) const;
+			ListInstancesOutcome listInstances(const Model::ListInstancesRequest &request)const;
+			void listInstancesAsync(const Model::ListInstancesRequest& request, const ListInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInstancesOutcomeCallable listInstancesCallable(const Model::ListInstancesRequest& request) const;
+			ListNodeIOOutcome listNodeIO(const Model::ListNodeIORequest &request)const;
+			void listNodeIOAsync(const Model::ListNodeIORequest& request, const ListNodeIOAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListNodeIOOutcomeCallable listNodeIOCallable(const Model::ListNodeIORequest& request) const;
+			ListNodesOutcome listNodes(const Model::ListNodesRequest &request)const;
+			void listNodesAsync(const Model::ListNodesRequest& request, const ListNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListNodesOutcomeCallable listNodesCallable(const Model::ListNodesRequest& request) const;
+			ListQualityRulesOutcome listQualityRules(const Model::ListQualityRulesRequest &request)const;
+			void listQualityRulesAsync(const Model::ListQualityRulesRequest& request, const ListQualityRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListQualityRulesOutcomeCallable listQualityRulesCallable(const Model::ListQualityRulesRequest& request) const;
+			ListRemindsOutcome listReminds(const Model::ListRemindsRequest &request)const;
+			void listRemindsAsync(const Model::ListRemindsRequest& request, const ListRemindsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListRemindsOutcomeCallable listRemindsCallable(const Model::ListRemindsRequest& request) const;
+			ListResourceGroupsOutcome listResourceGroups(const Model::ListResourceGroupsRequest &request)const;
+			void listResourceGroupsAsync(const Model::ListResourceGroupsRequest& request, const ListResourceGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListResourceGroupsOutcomeCallable listResourceGroupsCallable(const Model::ListResourceGroupsRequest& request) const;
+			ListTopicsOutcome listTopics(const Model::ListTopicsRequest &request)const;
+			void listTopicsAsync(const Model::ListTopicsRequest& request, const ListTopicsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTopicsOutcomeCallable listTopicsCallable(const Model::ListTopicsRequest& request) const;
+			PublishDataServiceApiOutcome publishDataServiceApi(const Model::PublishDataServiceApiRequest &request)const;
+			void publishDataServiceApiAsync(const Model::PublishDataServiceApiRequest& request, const PublishDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PublishDataServiceApiOutcomeCallable publishDataServiceApiCallable(const Model::PublishDataServiceApiRequest& request) const;
+			RestartInstanceOutcome restartInstance(const Model::RestartInstanceRequest &request)const;
+			void restartInstanceAsync(const Model::RestartInstanceRequest& request, const RestartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RestartInstanceOutcomeCallable restartInstanceCallable(const Model::RestartInstanceRequest& request) const;
+			ResumeInstanceOutcome resumeInstance(const Model::ResumeInstanceRequest &request)const;
+			void resumeInstanceAsync(const Model::ResumeInstanceRequest& request, const ResumeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResumeInstanceOutcomeCallable resumeInstanceCallable(const Model::ResumeInstanceRequest& request) const;
+			SearchMetaTablesOutcome searchMetaTables(const Model::SearchMetaTablesRequest &request)const;
+			void searchMetaTablesAsync(const Model::SearchMetaTablesRequest& request, const SearchMetaTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SearchMetaTablesOutcomeCallable searchMetaTablesCallable(const Model::SearchMetaTablesRequest& request) const;
+			SetSuccessInstanceOutcome setSuccessInstance(const Model::SetSuccessInstanceRequest &request)const;
+			void setSuccessInstanceAsync(const Model::SetSuccessInstanceRequest& request, const SetSuccessInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetSuccessInstanceOutcomeCallable setSuccessInstanceCallable(const Model::SetSuccessInstanceRequest& request) const;
+			StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const;
+			void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const;
+			SubmitFileOutcome submitFile(const Model::SubmitFileRequest &request)const;
+			void submitFileAsync(const Model::SubmitFileRequest& request, const SubmitFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SubmitFileOutcomeCallable submitFileCallable(const Model::SubmitFileRequest& request) const;
+			SuspendInstanceOutcome suspendInstance(const Model::SuspendInstanceRequest &request)const;
+			void suspendInstanceAsync(const Model::SuspendInstanceRequest& request, const SuspendInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SuspendInstanceOutcomeCallable suspendInstanceCallable(const Model::SuspendInstanceRequest& request) const;
+			UpdateBusinessOutcome updateBusiness(const Model::UpdateBusinessRequest &request)const;
+			void updateBusinessAsync(const Model::UpdateBusinessRequest& request, const UpdateBusinessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateBusinessOutcomeCallable updateBusinessCallable(const Model::UpdateBusinessRequest& request) const;
+			UpdateConnectionOutcome updateConnection(const Model::UpdateConnectionRequest &request)const;
+			void updateConnectionAsync(const Model::UpdateConnectionRequest& request, const UpdateConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateConnectionOutcomeCallable updateConnectionCallable(const Model::UpdateConnectionRequest& request) const;
+			UpdateDataServiceApiOutcome updateDataServiceApi(const Model::UpdateDataServiceApiRequest &request)const;
+			void updateDataServiceApiAsync(const Model::UpdateDataServiceApiRequest& request, const UpdateDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateDataServiceApiOutcomeCallable updateDataServiceApiCallable(const Model::UpdateDataServiceApiRequest& request) const;
+			UpdateFileOutcome updateFile(const Model::UpdateFileRequest &request)const;
+			void updateFileAsync(const Model::UpdateFileRequest& request, const UpdateFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateFileOutcomeCallable updateFileCallable(const Model::UpdateFileRequest& request) const;
+			UpdateFolderOutcome updateFolder(const Model::UpdateFolderRequest &request)const;
+			void updateFolderAsync(const Model::UpdateFolderRequest& request, const UpdateFolderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateFolderOutcomeCallable updateFolderCallable(const Model::UpdateFolderRequest& request) const;
+			UpdateMetaCategoryOutcome updateMetaCategory(const Model::UpdateMetaCategoryRequest &request)const;
+			void updateMetaCategoryAsync(const Model::UpdateMetaCategoryRequest& request, const UpdateMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateMetaCategoryOutcomeCallable updateMetaCategoryCallable(const Model::UpdateMetaCategoryRequest& request) const;
+			UpdateQualityFollowerOutcome updateQualityFollower(const Model::UpdateQualityFollowerRequest &request)const;
+			void updateQualityFollowerAsync(const Model::UpdateQualityFollowerRequest& request, const UpdateQualityFollowerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateQualityFollowerOutcomeCallable updateQualityFollowerCallable(const Model::UpdateQualityFollowerRequest& request) const;
+			UpdateQualityRuleOutcome updateQualityRule(const Model::UpdateQualityRuleRequest &request)const;
+			void updateQualityRuleAsync(const Model::UpdateQualityRuleRequest& request, const UpdateQualityRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateQualityRuleOutcomeCallable updateQualityRuleCallable(const Model::UpdateQualityRuleRequest& request) const;
+			UpdateRemindOutcome updateRemind(const Model::UpdateRemindRequest &request)const;
+			void updateRemindAsync(const Model::UpdateRemindRequest& request, const UpdateRemindAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateRemindOutcomeCallable updateRemindCallable(const Model::UpdateRemindRequest& request) const;
+			UpdateUdfFileOutcome updateUdfFile(const Model::UpdateUdfFileRequest &request)const;
+			void updateUdfFileAsync(const Model::UpdateUdfFileRequest& request, const UpdateUdfFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateUdfFileOutcomeCallable updateUdfFileCallable(const Model::UpdateUdfFileRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_DATAWORKS_PUBLICCLIENT_H_

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_DATAWORKS_PUBLICEXPORT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_DATAWORKS_PUBLICEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_DATAWORKS_PUBLIC_LIBRARY)
+#		define ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_DATAWORKS_PUBLICEXPORT_H_

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

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_ABOLISHDATASERVICEAPIREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_ABOLISHDATASERVICEAPIREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT AbolishDataServiceApiRequest : public RpcServiceRequest
+			{
+
+			public:
+				AbolishDataServiceApiRequest();
+				~AbolishDataServiceApiRequest();
+
+				long getTenantId()const;
+				void setTenantId(long tenantId);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				long getApiId()const;
+				void setApiId(long apiId);
+
+            private:
+				long tenantId_;
+				long projectId_;
+				long apiId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_ABOLISHDATASERVICEAPIREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/AbolishDataServiceApiResult.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_DATAWORKS_PUBLIC_MODEL_ABOLISHDATASERVICEAPIRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_ABOLISHDATASERVICEAPIRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT AbolishDataServiceApiResult : public ServiceResult
+			{
+			public:
+
+
+				AbolishDataServiceApiResult();
+				explicit AbolishDataServiceApiResult(const std::string &payload);
+				~AbolishDataServiceApiResult();
+				int getHttpStatusCode()const;
+				bool getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				bool data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_ABOLISHDATASERVICEAPIRESULT_H_

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

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

dataworks-public/include/alibabacloud/dataworks-public/model/AddToMetaCategoryResult.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_DATAWORKS_PUBLIC_MODEL_ADDTOMETACATEGORYRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_ADDTOMETACATEGORYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT AddToMetaCategoryResult : public ServiceResult
+			{
+			public:
+
+
+				AddToMetaCategoryResult();
+				explicit AddToMetaCategoryResult(const std::string &payload);
+				~AddToMetaCategoryResult();
+				int getHttpStatusCode()const;
+				bool getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				bool data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_ADDTOMETACATEGORYRESULT_H_

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

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

dataworks-public/include/alibabacloud/dataworks-public/model/CheckMetaPartitionResult.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_DATAWORKS_PUBLIC_MODEL_CHECKMETAPARTITIONRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CHECKMETAPARTITIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CheckMetaPartitionResult : public ServiceResult
+			{
+			public:
+
+
+				CheckMetaPartitionResult();
+				explicit CheckMetaPartitionResult(const std::string &payload);
+				~CheckMetaPartitionResult();
+				int getHttpStatusCode()const;
+				bool getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				bool data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CHECKMETAPARTITIONRESULT_H_

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

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

dataworks-public/include/alibabacloud/dataworks-public/model/CheckMetaTableResult.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_DATAWORKS_PUBLIC_MODEL_CHECKMETATABLERESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CHECKMETATABLERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CheckMetaTableResult : public ServiceResult
+			{
+			public:
+
+
+				CheckMetaTableResult();
+				explicit CheckMetaTableResult(const std::string &payload);
+				~CheckMetaTableResult();
+				int getHttpStatusCode()const;
+				bool getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				bool data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CHECKMETATABLERESULT_H_

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATECONNECTIONREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATECONNECTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateConnectionRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateConnectionRequest();
+				~CreateConnectionRequest();
+
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getContent()const;
+				void setContent(const std::string& content);
+				std::string getSubType()const;
+				void setSubType(const std::string& subType);
+				std::string getName()const;
+				void setName(const std::string& name);
+				int getEnvType()const;
+				void setEnvType(int envType);
+				std::string getConnectionType()const;
+				void setConnectionType(const std::string& connectionType);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string description_;
+				std::string content_;
+				std::string subType_;
+				std::string name_;
+				int envType_;
+				std::string connectionType_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATECONNECTIONREQUEST_H_

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

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

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

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDATASERVICEAPIREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDATASERVICEAPIREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateDataServiceApiRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDataServiceApiRequest();
+				~CreateDataServiceApiRequest();
+
+				std::string getScriptDetails()const;
+				void setScriptDetails(const std::string& scriptDetails);
+				int getRequestMethod()const;
+				void setRequestMethod(int requestMethod);
+				std::string getGroupId()const;
+				void setGroupId(const std::string& groupId);
+				std::string getApiPath()const;
+				void setApiPath(const std::string& apiPath);
+				std::string getWizardDetails()const;
+				void setWizardDetails(const std::string& wizardDetails);
+				int getApiMode()const;
+				void setApiMode(int apiMode);
+				int getVisibleRange()const;
+				void setVisibleRange(int visibleRange);
+				std::string getApiDescription()const;
+				void setApiDescription(const std::string& apiDescription);
+				int getTimeout()const;
+				void setTimeout(int timeout);
+				std::string getRegistrationDetails()const;
+				void setRegistrationDetails(const std::string& registrationDetails);
+				std::string getApiName()const;
+				void setApiName(const std::string& apiName);
+				long getTenantId()const;
+				void setTenantId(long tenantId);
+				std::string getProtocols()const;
+				void setProtocols(const std::string& protocols);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				int getResponseContentType()const;
+				void setResponseContentType(int responseContentType);
+
+            private:
+				std::string scriptDetails_;
+				int requestMethod_;
+				std::string groupId_;
+				std::string apiPath_;
+				std::string wizardDetails_;
+				int apiMode_;
+				int visibleRange_;
+				std::string apiDescription_;
+				int timeout_;
+				std::string registrationDetails_;
+				std::string apiName_;
+				long tenantId_;
+				std::string protocols_;
+				long projectId_;
+				int responseContentType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDATASERVICEAPIREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateDataServiceApiResult.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_DATAWORKS_PUBLIC_MODEL_CREATEDATASERVICEAPIRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDATASERVICEAPIRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateDataServiceApiResult : public ServiceResult
+			{
+			public:
+
+
+				CreateDataServiceApiResult();
+				explicit CreateDataServiceApiResult(const std::string &payload);
+				~CreateDataServiceApiResult();
+				int getHttpStatusCode()const;
+				long getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				long data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDATASERVICEAPIRESULT_H_

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

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEFILEREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEFILEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateFileRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateFileRequest();
+				~CreateFileRequest();
+
+				int getFileType()const;
+				void setFileType(int fileType);
+				std::string getContent()const;
+				void setContent(const std::string& content);
+				std::string getProjectIdentifier()const;
+				void setProjectIdentifier(const std::string& projectIdentifier);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				long getStartEffectDate()const;
+				void setStartEffectDate(long startEffectDate);
+				std::string getCycleType()const;
+				void setCycleType(const std::string& cycleType);
+				std::string getOwner()const;
+				void setOwner(const std::string& owner);
+				int getAutoRerunIntervalMillis()const;
+				void setAutoRerunIntervalMillis(int autoRerunIntervalMillis);
+				std::string getDependentCloudUuidList()const;
+				void setDependentCloudUuidList(const std::string& dependentCloudUuidList);
+				std::string getInputList()const;
+				void setInputList(const std::string& inputList);
+				std::string getRerunMode()const;
+				void setRerunMode(const std::string& rerunMode);
+				std::string getParaValue()const;
+				void setParaValue(const std::string& paraValue);
+				int getAutoRerunTimes()const;
+				void setAutoRerunTimes(int autoRerunTimes);
+				std::string getCronExpress()const;
+				void setCronExpress(const std::string& cronExpress);
+				long getEndEffectDate()const;
+				void setEndEffectDate(long endEffectDate);
+				std::string getFileName()const;
+				void setFileName(const std::string& fileName);
+				bool getStop()const;
+				void setStop(bool stop);
+				std::string getDependentType()const;
+				void setDependentType(const std::string& dependentType);
+				std::string getFileFolderPath()const;
+				void setFileFolderPath(const std::string& fileFolderPath);
+				std::string getFileDescription()const;
+				void setFileDescription(const std::string& fileDescription);
+
+            private:
+				int fileType_;
+				std::string content_;
+				std::string projectIdentifier_;
+				long projectId_;
+				long startEffectDate_;
+				std::string cycleType_;
+				std::string owner_;
+				int autoRerunIntervalMillis_;
+				std::string dependentCloudUuidList_;
+				std::string inputList_;
+				std::string rerunMode_;
+				std::string paraValue_;
+				int autoRerunTimes_;
+				std::string cronExpress_;
+				long endEffectDate_;
+				std::string fileName_;
+				bool stop_;
+				std::string dependentType_;
+				std::string fileFolderPath_;
+				std::string fileDescription_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEFILEREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateFileResult.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_DATAWORKS_PUBLIC_MODEL_CREATEFILERESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEFILERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateFileResult : public ServiceResult
+			{
+			public:
+
+
+				CreateFileResult();
+				explicit CreateFileResult(const std::string &payload);
+				~CreateFileResult();
+				int getHttpStatusCode()const;
+				long getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				long data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEFILERESULT_H_

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

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

dataworks-public/include/alibabacloud/dataworks-public/model/CreateFolderResult.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_DATAWORKS_PUBLIC_MODEL_CREATEFOLDERRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEFOLDERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateFolderResult : public ServiceResult
+			{
+			public:
+
+
+				CreateFolderResult();
+				explicit CreateFolderResult(const std::string &payload);
+				~CreateFolderResult();
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				std::string data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEFOLDERRESULT_H_

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

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

dataworks-public/include/alibabacloud/dataworks-public/model/CreateMetaCategoryResult.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_DATAWORKS_PUBLIC_MODEL_CREATEMETACATEGORYRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMETACATEGORYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateMetaCategoryResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					long categoryId;
+				};
+
+
+				CreateMetaCategoryResult();
+				explicit CreateMetaCategoryResult(const std::string &payload);
+				~CreateMetaCategoryResult();
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				Data data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMETACATEGORYRESULT_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateNodeComplementRequest.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_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateNodeComplementRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateNodeComplementRequest();
+				~CreateNodeComplementRequest();
+
+				std::string getProjectEnv()const;
+				void setProjectEnv(const std::string& projectEnv);
+				std::string getStartBizDate()const;
+				void setStartBizDate(const std::string& startBizDate);
+				bool getParallelism()const;
+				void setParallelism(bool parallelism);
+				std::string getBizBeginTime()const;
+				void setBizBeginTime(const std::string& bizBeginTime);
+				std::string getEndBizDate()const;
+				void setEndBizDate(const std::string& endBizDate);
+				std::string getIncludeNodeIds()const;
+				void setIncludeNodeIds(const std::string& includeNodeIds);
+				std::string getBizEndTime()const;
+				void setBizEndTime(const std::string& bizEndTime);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getExcludeNodeIds()const;
+				void setExcludeNodeIds(const std::string& excludeNodeIds);
+				long getNodeId()const;
+				void setNodeId(long nodeId);
+				long getNodeProjectId()const;
+				void setNodeProjectId(long nodeProjectId);
+
+            private:
+				std::string projectEnv_;
+				std::string startBizDate_;
+				bool parallelism_;
+				std::string bizBeginTime_;
+				std::string endBizDate_;
+				std::string includeNodeIds_;
+				std::string bizEndTime_;
+				std::string name_;
+				std::string excludeNodeIds_;
+				long nodeId_;
+				long nodeProjectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateNodeComplementResult.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_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateNodeComplementResult : public ServiceResult
+			{
+			public:
+
+
+				CreateNodeComplementResult();
+				explicit CreateNodeComplementResult(const std::string &payload);
+				~CreateNodeComplementResult();
+				int getHttpStatusCode()const;
+				long getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				long data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTRESULT_H_

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateNodeTestRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateNodeTestRequest();
+				~CreateNodeTestRequest();
+
+				std::string getProjectEnv()const;
+				void setProjectEnv(const std::string& projectEnv);
+				bool getParallelism()const;
+				void setParallelism(bool parallelism);
+				std::string getBizBeginTime()const;
+				void setBizBeginTime(const std::string& bizBeginTime);
+				std::string getIncludeNodeIds()const;
+				void setIncludeNodeIds(const std::string& includeNodeIds);
+				std::string getBizdate()const;
+				void setBizdate(const std::string& bizdate);
+				std::string getBizEndTime()const;
+				void setBizEndTime(const std::string& bizEndTime);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getExcludeNodeIds()const;
+				void setExcludeNodeIds(const std::string& excludeNodeIds);
+				long getNodeId()const;
+				void setNodeId(long nodeId);
+				long getNodeProjectId()const;
+				void setNodeProjectId(long nodeProjectId);
+
+            private:
+				std::string projectEnv_;
+				bool parallelism_;
+				std::string bizBeginTime_;
+				std::string includeNodeIds_;
+				std::string bizdate_;
+				std::string bizEndTime_;
+				std::string name_;
+				std::string excludeNodeIds_;
+				long nodeId_;
+				long nodeProjectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateNodeTestResult.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_DATAWORKS_PUBLIC_MODEL_CREATENODETESTRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateNodeTestResult : public ServiceResult
+			{
+			public:
+
+
+				CreateNodeTestResult();
+				explicit CreateNodeTestResult(const std::string &payload);
+				~CreateNodeTestResult();
+				int getHttpStatusCode()const;
+				long getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				long data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTRESULT_H_

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

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYENTITYREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYENTITYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateQualityEntityRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateQualityEntityRequest();
+				~CreateQualityEntityRequest();
+
+				std::string getProjectName()const;
+				void setProjectName(const std::string& projectName);
+				int getEntityLevel()const;
+				void setEntityLevel(int entityLevel);
+				std::string getMatchExpression()const;
+				void setMatchExpression(const std::string& matchExpression);
+				std::string getEnvType()const;
+				void setEnvType(const std::string& envType);
+				std::string getTableName()const;
+				void setTableName(const std::string& tableName);
+
+            private:
+				std::string projectName_;
+				int entityLevel_;
+				std::string matchExpression_;
+				std::string envType_;
+				std::string tableName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYENTITYREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateQualityEntityResult.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_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYENTITYRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYENTITYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateQualityEntityResult : public ServiceResult
+			{
+			public:
+
+
+				CreateQualityEntityResult();
+				explicit CreateQualityEntityResult(const std::string &payload);
+				~CreateQualityEntityResult();
+				int getHttpStatusCode()const;
+				int getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				int data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYENTITYRESULT_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateQualityFollowerRequest.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_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYFOLLOWERREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYFOLLOWERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateQualityFollowerRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateQualityFollowerRequest();
+				~CreateQualityFollowerRequest();
+
+				int getAlarmMode()const;
+				void setAlarmMode(int alarmMode);
+				std::string getProjectName()const;
+				void setProjectName(const std::string& projectName);
+				std::string getFollower()const;
+				void setFollower(const std::string& follower);
+				long getEntityId()const;
+				void setEntityId(long entityId);
+
+            private:
+				int alarmMode_;
+				std::string projectName_;
+				std::string follower_;
+				long entityId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYFOLLOWERREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateQualityFollowerResult.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_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYFOLLOWERRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYFOLLOWERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateQualityFollowerResult : public ServiceResult
+			{
+			public:
+
+
+				CreateQualityFollowerResult();
+				explicit CreateQualityFollowerResult(const std::string &payload);
+				~CreateQualityFollowerResult();
+				int getHttpStatusCode()const;
+				int getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				int data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYFOLLOWERRESULT_H_

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRELATIVENODEREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRELATIVENODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateQualityRelativeNodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateQualityRelativeNodeRequest();
+				~CreateQualityRelativeNodeRequest();
+
+				std::string getProjectName()const;
+				void setProjectName(const std::string& projectName);
+				long getTargetNodeProjectId()const;
+				void setTargetNodeProjectId(long targetNodeProjectId);
+				std::string getMatchExpression()const;
+				void setMatchExpression(const std::string& matchExpression);
+				std::string getEnvType()const;
+				void setEnvType(const std::string& envType);
+				std::string getTargetNodeProjectName()const;
+				void setTargetNodeProjectName(const std::string& targetNodeProjectName);
+				std::string getTableName()const;
+				void setTableName(const std::string& tableName);
+				long getNodeId()const;
+				void setNodeId(long nodeId);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string projectName_;
+				long targetNodeProjectId_;
+				std::string matchExpression_;
+				std::string envType_;
+				std::string targetNodeProjectName_;
+				std::string tableName_;
+				long nodeId_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRELATIVENODEREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateQualityRelativeNodeResult.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_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRELATIVENODERESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRELATIVENODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateQualityRelativeNodeResult : public ServiceResult
+			{
+			public:
+
+
+				CreateQualityRelativeNodeResult();
+				explicit CreateQualityRelativeNodeResult(const std::string &payload);
+				~CreateQualityRelativeNodeResult();
+				int getHttpStatusCode()const;
+				bool getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				bool data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRELATIVENODERESULT_H_

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

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRULEREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateQualityRuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateQualityRuleRequest();
+				~CreateQualityRuleRequest();
+
+				std::string getProjectName()const;
+				void setProjectName(const std::string& projectName);
+				std::string getTrend()const;
+				void setTrend(const std::string& trend);
+				int getRuleType()const;
+				void setRuleType(int ruleType);
+				int getBlockType()const;
+				void setBlockType(int blockType);
+				std::string getPropertyType()const;
+				void setPropertyType(const std::string& propertyType);
+				long getEntityId()const;
+				void setEntityId(long entityId);
+				std::string getRuleName()const;
+				void setRuleName(const std::string& ruleName);
+				int getChecker()const;
+				void setChecker(int checker);
+				int getTemplateId()const;
+				void setTemplateId(int templateId);
+				std::string getExpectValue()const;
+				void setExpectValue(const std::string& expectValue);
+				std::string get_Operator()const;
+				void set_Operator(const std::string& _operator);
+				std::string getWhereCondition()const;
+				void setWhereCondition(const std::string& whereCondition);
+				std::string getCriticalThreshold()const;
+				void setCriticalThreshold(const std::string& criticalThreshold);
+				std::string getProperty()const;
+				void setProperty(const std::string& property);
+				std::string getComment()const;
+				void setComment(const std::string& comment);
+				int getPredictType()const;
+				void setPredictType(int predictType);
+				std::string getWarningThreshold()const;
+				void setWarningThreshold(const std::string& warningThreshold);
+				std::string getMethodName()const;
+				void setMethodName(const std::string& methodName);
+
+            private:
+				std::string projectName_;
+				std::string trend_;
+				int ruleType_;
+				int blockType_;
+				std::string propertyType_;
+				long entityId_;
+				std::string ruleName_;
+				int checker_;
+				int templateId_;
+				std::string expectValue_;
+				std::string _operator_;
+				std::string whereCondition_;
+				std::string criticalThreshold_;
+				std::string property_;
+				std::string comment_;
+				int predictType_;
+				std::string warningThreshold_;
+				std::string methodName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRULEREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateQualityRuleResult.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_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRULERESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateQualityRuleResult : public ServiceResult
+			{
+			public:
+
+
+				CreateQualityRuleResult();
+				explicit CreateQualityRuleResult(const std::string &payload);
+				~CreateQualityRuleResult();
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				std::string data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEQUALITYRULERESULT_H_

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

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEREMINDREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEREMINDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateRemindRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateRemindRequest();
+				~CreateRemindRequest();
+
+				std::string getDndEnd()const;
+				void setDndEnd(const std::string& dndEnd);
+				std::string getAlertUnit()const;
+				void setAlertUnit(const std::string& alertUnit);
+				std::string getRemindUnit()const;
+				void setRemindUnit(const std::string& remindUnit);
+				int getAlertInterval()const;
+				void setAlertInterval(int alertInterval);
+				std::string getAlertMethods()const;
+				void setAlertMethods(const std::string& alertMethods);
+				std::string getRobotUrls()const;
+				void setRobotUrls(const std::string& robotUrls);
+				int getMaxAlertTimes()const;
+				void setMaxAlertTimes(int maxAlertTimes);
+				std::string getBizProcessIds()const;
+				void setBizProcessIds(const std::string& bizProcessIds);
+				std::string getRemindType()const;
+				void setRemindType(const std::string& remindType);
+				std::string getAlertTargets()const;
+				void setAlertTargets(const std::string& alertTargets);
+				std::string getBaselineIds()const;
+				void setBaselineIds(const std::string& baselineIds);
+				std::string getDetail()const;
+				void setDetail(const std::string& detail);
+				std::string getRemindName()const;
+				void setRemindName(const std::string& remindName);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				std::string getNodeIds()const;
+				void setNodeIds(const std::string& nodeIds);
+
+            private:
+				std::string dndEnd_;
+				std::string alertUnit_;
+				std::string remindUnit_;
+				int alertInterval_;
+				std::string alertMethods_;
+				std::string robotUrls_;
+				int maxAlertTimes_;
+				std::string bizProcessIds_;
+				std::string remindType_;
+				std::string alertTargets_;
+				std::string baselineIds_;
+				std::string detail_;
+				std::string remindName_;
+				long projectId_;
+				std::string nodeIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEREMINDREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateRemindResult.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_DATAWORKS_PUBLIC_MODEL_CREATEREMINDRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEREMINDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateRemindResult : public ServiceResult
+			{
+			public:
+
+
+				CreateRemindResult();
+				explicit CreateRemindResult(const std::string &payload);
+				~CreateRemindResult();
+				int getHttpStatusCode()const;
+				long getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				long data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEREMINDRESULT_H_

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

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEUDFFILEREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEUDFFILEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateUdfFileRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateUdfFileRequest();
+				~CreateUdfFileRequest();
+
+				std::string getReturnValue()const;
+				void setReturnValue(const std::string& returnValue);
+				std::string getResources()const;
+				void setResources(const std::string& resources);
+				std::string getFunctionType()const;
+				void setFunctionType(const std::string& functionType);
+				std::string getCmdDescription()const;
+				void setCmdDescription(const std::string& cmdDescription);
+				std::string getUdfDescription()const;
+				void setUdfDescription(const std::string& udfDescription);
+				std::string getParameterDescription()const;
+				void setParameterDescription(const std::string& parameterDescription);
+				std::string getProjectIdentifier()const;
+				void setProjectIdentifier(const std::string& projectIdentifier);
+				std::string getExample()const;
+				void setExample(const std::string& example);
+				std::string getFileName()const;
+				void setFileName(const std::string& fileName);
+				std::string getClassName()const;
+				void setClassName(const std::string& className);
+				std::string getFileFolderPath()const;
+				void setFileFolderPath(const std::string& fileFolderPath);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string returnValue_;
+				std::string resources_;
+				std::string functionType_;
+				std::string cmdDescription_;
+				std::string udfDescription_;
+				std::string parameterDescription_;
+				std::string projectIdentifier_;
+				std::string example_;
+				std::string fileName_;
+				std::string className_;
+				std::string fileFolderPath_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEUDFFILEREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateUdfFileResult.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_DATAWORKS_PUBLIC_MODEL_CREATEUDFFILERESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEUDFFILERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateUdfFileResult : public ServiceResult
+			{
+			public:
+
+
+				CreateUdfFileResult();
+				explicit CreateUdfFileResult(const std::string &payload);
+				~CreateUdfFileResult();
+				int getHttpStatusCode()const;
+				long getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				long data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEUDFFILERESULT_H_

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

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

dataworks-public/include/alibabacloud/dataworks-public/model/DeleteBusinessResult.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_DATAWORKS_PUBLIC_MODEL_DELETEBUSINESSRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_DELETEBUSINESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT DeleteBusinessResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteBusinessResult();
+				explicit DeleteBusinessResult(const std::string &payload);
+				~DeleteBusinessResult();
+				int getHttpStatusCode()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_DELETEBUSINESSRESULT_H_

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

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

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

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

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

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_DELETEDATASERVICEAPIREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_DELETEDATASERVICEAPIREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT DeleteDataServiceApiRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteDataServiceApiRequest();
+				~DeleteDataServiceApiRequest();
+
+				long getTenantId()const;
+				void setTenantId(long tenantId);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				long getApiId()const;
+				void setApiId(long apiId);
+
+            private:
+				long tenantId_;
+				long projectId_;
+				long apiId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_DELETEDATASERVICEAPIREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/DeleteDataServiceApiResult.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_DATAWORKS_PUBLIC_MODEL_DELETEDATASERVICEAPIRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_DELETEDATASERVICEAPIRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT DeleteDataServiceApiResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteDataServiceApiResult();
+				explicit DeleteDataServiceApiResult(const std::string &payload);
+				~DeleteDataServiceApiResult();
+				int getHttpStatusCode()const;
+				bool getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				bool data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_DELETEDATASERVICEAPIRESULT_H_

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

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

dataworks-public/include/alibabacloud/dataworks-public/model/DeleteFileResult.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_DATAWORKS_PUBLIC_MODEL_DELETEFILERESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_DELETEFILERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT DeleteFileResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteFileResult();
+				explicit DeleteFileResult(const std::string &payload);
+				~DeleteFileResult();
+				int getHttpStatusCode()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_DELETEFILERESULT_H_