Generated 2019-09-01 for OceanBasePro.

README-CN.md

@@ -11,9 +11,9 @@
 <a href="https://codecov.io/gh/aliyun/aliyun-openapi-cpp-sdk"><img src="https://codecov.io/gh/aliyun/aliyun-openapi-cpp-sdk/branch/master/graph/badge.svg" alt="codecov"></a>
 </p>
 
-Alibaba Cloud SDK for C++ 让您不用复杂编程即可访问云服务器、负载均衡、云监控等阿里云服务。这里向您介绍如何获取 Alibaba Cloud SDK for C++ 并开始调用。
+阿里云 V1.0 SDK 即将进入基础安全维护阶段，不再建议使用，建议使用 V2.0 SDK。
 
-如果您在使用的过程中遇到任何问题，欢迎前往[阿里云SDK问答社区](https://yq.aliyun.com/tags/type_ask-tagid_23350)提问，提问前请阅读[提问引导](https://help.aliyun.com/document_detail/93957.html)。亦可在当前 GitHub [提交 Issues](https://github.com/aliyun/aliyun-openapi-cpp-sdk/issues/new)。
+如果您在使用的过程中遇到任何问题，可在当前 GitHub [提交 Issues](https://github.com/aliyun/aliyun-openapi-cpp-sdk/issues/new)。
 
 ## 使用诊断
 

README.md

@@ -11,9 +11,7 @@ English | [简体中文](./README-CN.md)
 <a href="https://codecov.io/gh/aliyun/aliyun-openapi-cpp-sdk"><img src="https://codecov.io/gh/aliyun/aliyun-openapi-cpp-sdk/branch/master/graph/badge.svg" alt="codecov"></a>
 </p>
 
-Alibaba Cloud SDK for C++ allows you to access Alibaba Cloud services such as Elastic Compute Service (ECS), Server Load Balancer (SLB), and CloudMonitor. You can access Alibaba Cloud services without the need to handle API related tasks, such as signing and constructing your requests.
-
-This document introduces how to obtain and call this SDK.
+The Alibaba Cloud V1.0 SDK will soon enter the Basic Security Maintenance phase and is no longer recommended for use. It is suggested to use the V2.0 SDK instead.
 
 If you have any problem while using Alibaba Cloud SDK for C++, please submit an [issue](https://github.com/aliyun/aliyun-openapi-cpp-sdk/issues/new).
 

VERSION

@@ -1 +1 @@
-1.36.2016
+1.36.2086

aimath/CMakeLists.txt

@@ -0,0 +1,102 @@
+#
+# 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(aimath_public_header 
+	include/alibabacloud/aimath/AIMathClient.h
+	include/alibabacloud/aimath/AIMathExport.h )
+
+set(aimath_public_header_model 
+	include/alibabacloud/aimath/model/GenAnalysisRequest.h
+	include/alibabacloud/aimath/model/GenAnalysisResult.h
+	include/alibabacloud/aimath/model/GenStepRequest.h
+	include/alibabacloud/aimath/model/GenStepResult.h
+	include/alibabacloud/aimath/model/GlobalConfirmRequest.h
+	include/alibabacloud/aimath/model/GlobalConfirmResult.h
+	include/alibabacloud/aimath/model/UpdateAnalysisRequest.h
+	include/alibabacloud/aimath/model/UpdateAnalysisResult.h
+	include/alibabacloud/aimath/model/UpdateStepRequest.h
+	include/alibabacloud/aimath/model/UpdateStepResult.h )
+
+set(aimath_src 
+	src/AIMathClient.cc
+	src/model/GenAnalysisRequest.cc
+	src/model/GenAnalysisResult.cc
+	src/model/GenStepRequest.cc
+	src/model/GenStepResult.cc
+	src/model/GlobalConfirmRequest.cc
+	src/model/GlobalConfirmResult.cc
+	src/model/UpdateAnalysisRequest.cc
+	src/model/UpdateAnalysisResult.cc
+	src/model/UpdateStepRequest.cc
+	src/model/UpdateStepResult.cc )
+
+add_library(aimath ${LIB_TYPE}
+	${aimath_public_header}
+	${aimath_public_header_model}
+	${aimath_src})
+
+set_target_properties(aimath
+	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}aimath
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(aimath
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_AIMATH_LIBRARY)
+endif()
+
+target_include_directories(aimath
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(aimath
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(aimath
+		jsoncpp)
+	target_include_directories(aimath
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(aimath
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(aimath
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(aimath
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(aimath
+		jsoncpp)
+endif()
+
+install(FILES ${aimath_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/aimath)
+install(FILES ${aimath_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/aimath/model)
+install(TARGETS aimath
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

aimath/include/alibabacloud/aimath/AIMathClient.h

@@ -0,0 +1,86 @@
+/*
+ * 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_AIMATH_AIMATHCLIENT_H_
+#define ALIBABACLOUD_AIMATH_AIMATHCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "AIMathExport.h"
+#include "model/GenAnalysisRequest.h"
+#include "model/GenAnalysisResult.h"
+#include "model/GenStepRequest.h"
+#include "model/GenStepResult.h"
+#include "model/GlobalConfirmRequest.h"
+#include "model/GlobalConfirmResult.h"
+#include "model/UpdateAnalysisRequest.h"
+#include "model/UpdateAnalysisResult.h"
+#include "model/UpdateStepRequest.h"
+#include "model/UpdateStepResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		class ALIBABACLOUD_AIMATH_EXPORT AIMathClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::GenAnalysisResult> GenAnalysisOutcome;
+			typedef std::future<GenAnalysisOutcome> GenAnalysisOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::GenAnalysisRequest&, const GenAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenAnalysisAsyncHandler;
+			typedef Outcome<Error, Model::GenStepResult> GenStepOutcome;
+			typedef std::future<GenStepOutcome> GenStepOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::GenStepRequest&, const GenStepOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenStepAsyncHandler;
+			typedef Outcome<Error, Model::GlobalConfirmResult> GlobalConfirmOutcome;
+			typedef std::future<GlobalConfirmOutcome> GlobalConfirmOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::GlobalConfirmRequest&, const GlobalConfirmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GlobalConfirmAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAnalysisResult> UpdateAnalysisOutcome;
+			typedef std::future<UpdateAnalysisOutcome> UpdateAnalysisOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::UpdateAnalysisRequest&, const UpdateAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAnalysisAsyncHandler;
+			typedef Outcome<Error, Model::UpdateStepResult> UpdateStepOutcome;
+			typedef std::future<UpdateStepOutcome> UpdateStepOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::UpdateStepRequest&, const UpdateStepOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateStepAsyncHandler;
+
+			AIMathClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			AIMathClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			AIMathClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~AIMathClient();
+			GenAnalysisOutcome genAnalysis(const Model::GenAnalysisRequest &request)const;
+			void genAnalysisAsync(const Model::GenAnalysisRequest& request, const GenAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenAnalysisOutcomeCallable genAnalysisCallable(const Model::GenAnalysisRequest& request) const;
+			GenStepOutcome genStep(const Model::GenStepRequest &request)const;
+			void genStepAsync(const Model::GenStepRequest& request, const GenStepAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenStepOutcomeCallable genStepCallable(const Model::GenStepRequest& request) const;
+			GlobalConfirmOutcome globalConfirm(const Model::GlobalConfirmRequest &request)const;
+			void globalConfirmAsync(const Model::GlobalConfirmRequest& request, const GlobalConfirmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GlobalConfirmOutcomeCallable globalConfirmCallable(const Model::GlobalConfirmRequest& request) const;
+			UpdateAnalysisOutcome updateAnalysis(const Model::UpdateAnalysisRequest &request)const;
+			void updateAnalysisAsync(const Model::UpdateAnalysisRequest& request, const UpdateAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAnalysisOutcomeCallable updateAnalysisCallable(const Model::UpdateAnalysisRequest& request) const;
+			UpdateStepOutcome updateStep(const Model::UpdateStepRequest &request)const;
+			void updateStepAsync(const Model::UpdateStepRequest& request, const UpdateStepAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateStepOutcomeCallable updateStepCallable(const Model::UpdateStepRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_AIMATH_AIMATHCLIENT_H_

aimath/include/alibabacloud/aimath/AIMathExport.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_AIMATH_AIMATHEXPORT_H_
+#define ALIBABACLOUD_AIMATH_AIMATHEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_AIMATH_LIBRARY)
+#		define ALIBABACLOUD_AIMATH_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_AIMATH_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_AIMATH_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_AIMATH_AIMATHEXPORT_H_

aimath/include/alibabacloud/aimath/model/GenAnalysisRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_AIMATH_MODEL_GENANALYSISREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GENANALYSISREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT GenAnalysisRequest : public RpcServiceRequest {
+public:
+	GenAnalysisRequest();
+	~GenAnalysisRequest();
+	std::string getExerciseContent() const;
+	void setExerciseContent(const std::string &exerciseContent);
+
+private:
+	std::string exerciseContent_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GENANALYSISREQUEST_H_

aimath/include/alibabacloud/aimath/model/GenAnalysisResult.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_AIMATH_MODEL_GENANALYSISRESULT_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GENANALYSISRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/aimath/AIMathExport.h>
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AIMATH_EXPORT GenAnalysisResult : public ServiceResult
+			{
+			public:
+
+
+				GenAnalysisResult();
+				explicit GenAnalysisResult(const std::string &payload);
+				~GenAnalysisResult();
+				std::string getEventType()const;
+				std::string getErrMsg()const;
+				std::string getContent()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string eventType_;
+				std::string errMsg_;
+				std::string content_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GENANALYSISRESULT_H_

aimath/include/alibabacloud/aimath/model/GenStepRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_AIMATH_MODEL_GENSTEPREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GENSTEPREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT GenStepRequest : public RpcServiceRequest {
+public:
+	GenStepRequest();
+	~GenStepRequest();
+	std::string getExerciseCode() const;
+	void setExerciseCode(const std::string &exerciseCode);
+
+private:
+	std::string exerciseCode_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GENSTEPREQUEST_H_

aimath/include/alibabacloud/aimath/model/GenStepResult.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_AIMATH_MODEL_GENSTEPRESULT_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GENSTEPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/aimath/AIMathExport.h>
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AIMATH_EXPORT GenStepResult : public ServiceResult
+			{
+			public:
+
+
+				GenStepResult();
+				explicit GenStepResult(const std::string &payload);
+				~GenStepResult();
+				std::string getEventType()const;
+				std::string getErrMsg()const;
+				std::string getContent()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string eventType_;
+				std::string errMsg_;
+				std::string content_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GENSTEPRESULT_H_

aimath/include/alibabacloud/aimath/model/GlobalConfirmRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_AIMATH_MODEL_GLOBALCONFIRMREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GLOBALCONFIRMREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT GlobalConfirmRequest : public RpcServiceRequest {
+public:
+	GlobalConfirmRequest();
+	~GlobalConfirmRequest();
+	std::string getTag() const;
+	void setTag(const std::string &tag);
+	std::string getExerciseCode() const;
+	void setExerciseCode(const std::string &exerciseCode);
+
+private:
+	std::string tag_;
+	std::string exerciseCode_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GLOBALCONFIRMREQUEST_H_

aimath/include/alibabacloud/aimath/model/GlobalConfirmResult.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_AIMATH_MODEL_GLOBALCONFIRMRESULT_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GLOBALCONFIRMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/aimath/AIMathExport.h>
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AIMATH_EXPORT GlobalConfirmResult : public ServiceResult
+			{
+			public:
+
+
+				GlobalConfirmResult();
+				explicit GlobalConfirmResult(const std::string &payload);
+				~GlobalConfirmResult();
+				std::string getErrMsg()const;
+				bool getSuccess()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errMsg_;
+				bool success_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GLOBALCONFIRMRESULT_H_

aimath/include/alibabacloud/aimath/model/UpdateAnalysisRequest.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_AIMATH_MODEL_UPDATEANALYSISREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_UPDATEANALYSISREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT UpdateAnalysisRequest : public RpcServiceRequest {
+public:
+	UpdateAnalysisRequest();
+	~UpdateAnalysisRequest();
+	std::string getContent() const;
+	void setContent(const std::string &content);
+	std::string getContentCode() const;
+	void setContentCode(const std::string &contentCode);
+	std::string getExerciseCode() const;
+	void setExerciseCode(const std::string &exerciseCode);
+
+private:
+	std::string content_;
+	std::string contentCode_;
+	std::string exerciseCode_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_UPDATEANALYSISREQUEST_H_

aimath/include/alibabacloud/aimath/model/UpdateAnalysisResult.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_AIMATH_MODEL_UPDATEANALYSISRESULT_H_
+#define ALIBABACLOUD_AIMATH_MODEL_UPDATEANALYSISRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/aimath/AIMathExport.h>
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AIMATH_EXPORT UpdateAnalysisResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateAnalysisResult();
+				explicit UpdateAnalysisResult(const std::string &payload);
+				~UpdateAnalysisResult();
+				std::string getErrMsg()const;
+				bool getSuccess()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errMsg_;
+				bool success_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AIMATH_MODEL_UPDATEANALYSISRESULT_H_

aimath/include/alibabacloud/aimath/model/UpdateStepRequest.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_AIMATH_MODEL_UPDATESTEPREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_UPDATESTEPREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT UpdateStepRequest : public RpcServiceRequest {
+public:
+	UpdateStepRequest();
+	~UpdateStepRequest();
+	std::string getContent() const;
+	void setContent(const std::string &content);
+	std::string getContentCode() const;
+	void setContentCode(const std::string &contentCode);
+	std::string getExerciseCode() const;
+	void setExerciseCode(const std::string &exerciseCode);
+
+private:
+	std::string content_;
+	std::string contentCode_;
+	std::string exerciseCode_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_UPDATESTEPREQUEST_H_

aimath/include/alibabacloud/aimath/model/UpdateStepResult.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_AIMATH_MODEL_UPDATESTEPRESULT_H_
+#define ALIBABACLOUD_AIMATH_MODEL_UPDATESTEPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/aimath/AIMathExport.h>
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AIMATH_EXPORT UpdateStepResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateStepResult();
+				explicit UpdateStepResult(const std::string &payload);
+				~UpdateStepResult();
+				std::string getErrMsg()const;
+				bool getSuccess()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errMsg_;
+				bool success_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AIMATH_MODEL_UPDATESTEPRESULT_H_

aimath/src/AIMathClient.cc

@@ -0,0 +1,233 @@
+/*
+ * 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/aimath/AIMathClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "AIMath";
+}
+
+AIMathClient::AIMathClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+AIMathClient::AIMathClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+AIMathClient::AIMathClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+AIMathClient::~AIMathClient()
+{}
+
+AIMathClient::GenAnalysisOutcome AIMathClient::genAnalysis(const GenAnalysisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GenAnalysisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GenAnalysisOutcome(GenAnalysisResult(outcome.result()));
+	else
+		return GenAnalysisOutcome(outcome.error());
+}
+
+void AIMathClient::genAnalysisAsync(const GenAnalysisRequest& request, const GenAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, genAnalysis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::GenAnalysisOutcomeCallable AIMathClient::genAnalysisCallable(const GenAnalysisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GenAnalysisOutcome()>>(
+			[this, request]()
+			{
+			return this->genAnalysis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AIMathClient::GenStepOutcome AIMathClient::genStep(const GenStepRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GenStepOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GenStepOutcome(GenStepResult(outcome.result()));
+	else
+		return GenStepOutcome(outcome.error());
+}
+
+void AIMathClient::genStepAsync(const GenStepRequest& request, const GenStepAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, genStep(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::GenStepOutcomeCallable AIMathClient::genStepCallable(const GenStepRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GenStepOutcome()>>(
+			[this, request]()
+			{
+			return this->genStep(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AIMathClient::GlobalConfirmOutcome AIMathClient::globalConfirm(const GlobalConfirmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GlobalConfirmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GlobalConfirmOutcome(GlobalConfirmResult(outcome.result()));
+	else
+		return GlobalConfirmOutcome(outcome.error());
+}
+
+void AIMathClient::globalConfirmAsync(const GlobalConfirmRequest& request, const GlobalConfirmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, globalConfirm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::GlobalConfirmOutcomeCallable AIMathClient::globalConfirmCallable(const GlobalConfirmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GlobalConfirmOutcome()>>(
+			[this, request]()
+			{
+			return this->globalConfirm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AIMathClient::UpdateAnalysisOutcome AIMathClient::updateAnalysis(const UpdateAnalysisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateAnalysisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateAnalysisOutcome(UpdateAnalysisResult(outcome.result()));
+	else
+		return UpdateAnalysisOutcome(outcome.error());
+}
+
+void AIMathClient::updateAnalysisAsync(const UpdateAnalysisRequest& request, const UpdateAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateAnalysis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::UpdateAnalysisOutcomeCallable AIMathClient::updateAnalysisCallable(const UpdateAnalysisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateAnalysisOutcome()>>(
+			[this, request]()
+			{
+			return this->updateAnalysis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AIMathClient::UpdateStepOutcome AIMathClient::updateStep(const UpdateStepRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateStepOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateStepOutcome(UpdateStepResult(outcome.result()));
+	else
+		return UpdateStepOutcome(outcome.error());
+}
+
+void AIMathClient::updateStepAsync(const UpdateStepRequest& request, const UpdateStepAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateStep(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::UpdateStepOutcomeCallable AIMathClient::updateStepCallable(const UpdateStepRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateStepOutcome()>>(
+			[this, request]()
+			{
+			return this->updateStep(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

aimath/src/model/GenAnalysisRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/aimath/model/GenAnalysisRequest.h>
+
+using AlibabaCloud::AIMath::Model::GenAnalysisRequest;
+
+GenAnalysisRequest::GenAnalysisRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "GenAnalysis") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GenAnalysisRequest::~GenAnalysisRequest() {}
+
+std::string GenAnalysisRequest::getExerciseContent() const {
+  return exerciseContent_;
+}
+
+void GenAnalysisRequest::setExerciseContent(const std::string &exerciseContent) {
+  exerciseContent_ = exerciseContent;
+  setBodyParameter(std::string("ExerciseContent"), exerciseContent);
+}
+

aimath/src/model/GenAnalysisResult.cc

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

aimath/src/model/GenStepRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/aimath/model/GenStepRequest.h>
+
+using AlibabaCloud::AIMath::Model::GenStepRequest;
+
+GenStepRequest::GenStepRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "GenStep") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GenStepRequest::~GenStepRequest() {}
+
+std::string GenStepRequest::getExerciseCode() const {
+  return exerciseCode_;
+}
+
+void GenStepRequest::setExerciseCode(const std::string &exerciseCode) {
+  exerciseCode_ = exerciseCode;
+  setBodyParameter(std::string("ExerciseCode"), exerciseCode);
+}
+

aimath/src/model/GenStepResult.cc

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

aimath/src/model/GlobalConfirmRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/aimath/model/GlobalConfirmRequest.h>
+
+using AlibabaCloud::AIMath::Model::GlobalConfirmRequest;
+
+GlobalConfirmRequest::GlobalConfirmRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "GlobalConfirm") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GlobalConfirmRequest::~GlobalConfirmRequest() {}
+
+std::string GlobalConfirmRequest::getTag() const {
+  return tag_;
+}
+
+void GlobalConfirmRequest::setTag(const std::string &tag) {
+  tag_ = tag;
+  setBodyParameter(std::string("Tag"), tag);
+}
+
+std::string GlobalConfirmRequest::getExerciseCode() const {
+  return exerciseCode_;
+}
+
+void GlobalConfirmRequest::setExerciseCode(const std::string &exerciseCode) {
+  exerciseCode_ = exerciseCode;
+  setBodyParameter(std::string("ExerciseCode"), exerciseCode);
+}
+

aimath/src/model/GlobalConfirmResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/aimath/model/GlobalConfirmResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+GlobalConfirmResult::GlobalConfirmResult() :
+	ServiceResult()
+{}
+
+GlobalConfirmResult::GlobalConfirmResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GlobalConfirmResult::~GlobalConfirmResult()
+{}
+
+void GlobalConfirmResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMsg"].isNull())
+		errMsg_ = value["ErrMsg"].asString();
+
+}
+
+std::string GlobalConfirmResult::getErrMsg()const
+{
+	return errMsg_;
+}
+
+bool GlobalConfirmResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string GlobalConfirmResult::getErrCode()const
+{
+	return errCode_;
+}
+

aimath/src/model/UpdateAnalysisRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/aimath/model/UpdateAnalysisRequest.h>
+
+using AlibabaCloud::AIMath::Model::UpdateAnalysisRequest;
+
+UpdateAnalysisRequest::UpdateAnalysisRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "UpdateAnalysis") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateAnalysisRequest::~UpdateAnalysisRequest() {}
+
+std::string UpdateAnalysisRequest::getContent() const {
+  return content_;
+}
+
+void UpdateAnalysisRequest::setContent(const std::string &content) {
+  content_ = content;
+  setBodyParameter(std::string("Content"), content);
+}
+
+std::string UpdateAnalysisRequest::getContentCode() const {
+  return contentCode_;
+}
+
+void UpdateAnalysisRequest::setContentCode(const std::string &contentCode) {
+  contentCode_ = contentCode;
+  setBodyParameter(std::string("ContentCode"), contentCode);
+}
+
+std::string UpdateAnalysisRequest::getExerciseCode() const {
+  return exerciseCode_;
+}
+
+void UpdateAnalysisRequest::setExerciseCode(const std::string &exerciseCode) {
+  exerciseCode_ = exerciseCode;
+  setBodyParameter(std::string("ExerciseCode"), exerciseCode);
+}
+

aimath/src/model/UpdateAnalysisResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/aimath/model/UpdateAnalysisResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+UpdateAnalysisResult::UpdateAnalysisResult() :
+	ServiceResult()
+{}
+
+UpdateAnalysisResult::UpdateAnalysisResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateAnalysisResult::~UpdateAnalysisResult()
+{}
+
+void UpdateAnalysisResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMsg"].isNull())
+		errMsg_ = value["ErrMsg"].asString();
+
+}
+
+std::string UpdateAnalysisResult::getErrMsg()const
+{
+	return errMsg_;
+}
+
+bool UpdateAnalysisResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string UpdateAnalysisResult::getErrCode()const
+{
+	return errCode_;
+}
+

aimath/src/model/UpdateStepRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/aimath/model/UpdateStepRequest.h>
+
+using AlibabaCloud::AIMath::Model::UpdateStepRequest;
+
+UpdateStepRequest::UpdateStepRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "UpdateStep") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateStepRequest::~UpdateStepRequest() {}
+
+std::string UpdateStepRequest::getContent() const {
+  return content_;
+}
+
+void UpdateStepRequest::setContent(const std::string &content) {
+  content_ = content;
+  setBodyParameter(std::string("Content"), content);
+}
+
+std::string UpdateStepRequest::getContentCode() const {
+  return contentCode_;
+}
+
+void UpdateStepRequest::setContentCode(const std::string &contentCode) {
+  contentCode_ = contentCode;
+  setBodyParameter(std::string("ContentCode"), contentCode);
+}
+
+std::string UpdateStepRequest::getExerciseCode() const {
+  return exerciseCode_;
+}
+
+void UpdateStepRequest::setExerciseCode(const std::string &exerciseCode) {
+  exerciseCode_ = exerciseCode;
+  setBodyParameter(std::string("ExerciseCode"), exerciseCode);
+}
+

aimath/src/model/UpdateStepResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/aimath/model/UpdateStepResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+UpdateStepResult::UpdateStepResult() :
+	ServiceResult()
+{}
+
+UpdateStepResult::UpdateStepResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateStepResult::~UpdateStepResult()
+{}
+
+void UpdateStepResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMsg"].isNull())
+		errMsg_ = value["ErrMsg"].asString();
+
+}
+
+std::string UpdateStepResult::getErrMsg()const
+{
+	return errMsg_;
+}
+
+bool UpdateStepResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string UpdateStepResult::getErrCode()const
+{
+	return errCode_;
+}
+

aipodcast/CMakeLists.txt

@@ -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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(aipodcast_public_header 
+	include/alibabacloud/aipodcast/AIPodcastClient.h
+	include/alibabacloud/aipodcast/AIPodcastExport.h )
+
+set(aipodcast_public_header_model 
+	include/alibabacloud/aipodcast/model/PodcastTaskResultQueryRequest.h
+	include/alibabacloud/aipodcast/model/PodcastTaskResultQueryResult.h
+	include/alibabacloud/aipodcast/model/PodcastTaskSubmitRequest.h
+	include/alibabacloud/aipodcast/model/PodcastTaskSubmitResult.h )
+
+set(aipodcast_src 
+	src/AIPodcastClient.cc
+	src/model/PodcastTaskResultQueryRequest.cc
+	src/model/PodcastTaskResultQueryResult.cc
+	src/model/PodcastTaskSubmitRequest.cc
+	src/model/PodcastTaskSubmitResult.cc )
+
+add_library(aipodcast ${LIB_TYPE}
+	${aipodcast_public_header}
+	${aipodcast_public_header_model}
+	${aipodcast_src})
+
+set_target_properties(aipodcast
+	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}aipodcast
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(aipodcast
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_AIPODCAST_LIBRARY)
+endif()
+
+target_include_directories(aipodcast
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(aipodcast
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(aipodcast
+		jsoncpp)
+	target_include_directories(aipodcast
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(aipodcast
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(aipodcast
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(aipodcast
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(aipodcast
+		jsoncpp)
+endif()
+
+install(FILES ${aipodcast_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/aipodcast)
+install(FILES ${aipodcast_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/aipodcast/model)
+install(TARGETS aipodcast
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

aipodcast/include/alibabacloud/aipodcast/AIPodcastClient.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_AIPODCAST_AIPODCASTCLIENT_H_
+#define ALIBABACLOUD_AIPODCAST_AIPODCASTCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RoaServiceClient.h>
+#include "AIPodcastExport.h"
+#include "model/PodcastTaskResultQueryRequest.h"
+#include "model/PodcastTaskResultQueryResult.h"
+#include "model/PodcastTaskSubmitRequest.h"
+#include "model/PodcastTaskSubmitResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace AIPodcast
+	{
+		class ALIBABACLOUD_AIPODCAST_EXPORT AIPodcastClient : public RoaServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::PodcastTaskResultQueryResult> PodcastTaskResultQueryOutcome;
+			typedef std::future<PodcastTaskResultQueryOutcome> PodcastTaskResultQueryOutcomeCallable;
+			typedef std::function<void(const AIPodcastClient*, const Model::PodcastTaskResultQueryRequest&, const PodcastTaskResultQueryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PodcastTaskResultQueryAsyncHandler;
+			typedef Outcome<Error, Model::PodcastTaskSubmitResult> PodcastTaskSubmitOutcome;
+			typedef std::future<PodcastTaskSubmitOutcome> PodcastTaskSubmitOutcomeCallable;
+			typedef std::function<void(const AIPodcastClient*, const Model::PodcastTaskSubmitRequest&, const PodcastTaskSubmitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PodcastTaskSubmitAsyncHandler;
+
+			AIPodcastClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			AIPodcastClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			AIPodcastClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~AIPodcastClient();
+			PodcastTaskResultQueryOutcome podcastTaskResultQuery(const Model::PodcastTaskResultQueryRequest &request)const;
+			void podcastTaskResultQueryAsync(const Model::PodcastTaskResultQueryRequest& request, const PodcastTaskResultQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PodcastTaskResultQueryOutcomeCallable podcastTaskResultQueryCallable(const Model::PodcastTaskResultQueryRequest& request) const;
+			PodcastTaskSubmitOutcome podcastTaskSubmit(const Model::PodcastTaskSubmitRequest &request)const;
+			void podcastTaskSubmitAsync(const Model::PodcastTaskSubmitRequest& request, const PodcastTaskSubmitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PodcastTaskSubmitOutcomeCallable podcastTaskSubmitCallable(const Model::PodcastTaskSubmitRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_AIPODCAST_AIPODCASTCLIENT_H_

aipodcast/include/alibabacloud/aipodcast/AIPodcastExport.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_AIPODCAST_AIPODCASTEXPORT_H_
+#define ALIBABACLOUD_AIPODCAST_AIPODCASTEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_AIPODCAST_LIBRARY)
+#		define ALIBABACLOUD_AIPODCAST_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_AIPODCAST_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_AIPODCAST_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_AIPODCAST_AIPODCASTEXPORT_H_

aipodcast/include/alibabacloud/aipodcast/model/PodcastTaskResultQueryRequest.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_AIPODCAST_MODEL_PODCASTTASKRESULTQUERYREQUEST_H_
+#define ALIBABACLOUD_AIPODCAST_MODEL_PODCASTTASKRESULTQUERYREQUEST_H_
+
+#include <alibabacloud/aipodcast/AIPodcastExport.h>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIPodcast {
+namespace Model {
+class ALIBABACLOUD_AIPODCAST_EXPORT PodcastTaskResultQueryRequest : public RoaServiceRequest {
+public:
+	PodcastTaskResultQueryRequest();
+	~PodcastTaskResultQueryRequest();
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string getTaskId() const;
+	void setTaskId(const std::string &taskId);
+	std::string getWorkspaceId() const;
+	void setWorkspaceId(const std::string &workspaceId);
+
+private:
+	std::string appId_;
+	std::string taskId_;
+	std::string workspaceId_;
+};
+} // namespace Model
+} // namespace AIPodcast
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIPODCAST_MODEL_PODCASTTASKRESULTQUERYREQUEST_H_

aipodcast/include/alibabacloud/aipodcast/model/PodcastTaskResultQueryResult.h

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

aipodcast/include/alibabacloud/aipodcast/model/PodcastTaskSubmitRequest.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_AIPODCAST_MODEL_PODCASTTASKSUBMITREQUEST_H_
+#define ALIBABACLOUD_AIPODCAST_MODEL_PODCASTTASKSUBMITREQUEST_H_
+
+#include <alibabacloud/aipodcast/AIPodcastExport.h>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIPodcast {
+namespace Model {
+class ALIBABACLOUD_AIPODCAST_EXPORT PodcastTaskSubmitRequest : public RoaServiceRequest {
+public:
+	PodcastTaskSubmitRequest();
+	~PodcastTaskSubmitRequest();
+	std::string getAtmosphere() const;
+	void setAtmosphere(const std::string &atmosphere);
+	std::string getSourceLang() const;
+	void setSourceLang(const std::string &sourceLang);
+	int getCounts() const;
+	void setCounts(int counts);
+	std::vector<std::string> getFileUrls() const;
+	void setFileUrls(const std::vector<std::string> &fileUrls);
+	std::string getText() const;
+	void setText(const std::string &text);
+	std::vector<std::string> getVoices() const;
+	void setVoices(const std::vector<std::string> &voices);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string getTopic() const;
+	void setTopic(const std::string &topic);
+	std::string getStyle() const;
+	void setStyle(const std::string &style);
+	std::string getWorkspaceId() const;
+	void setWorkspaceId(const std::string &workspaceId);
+
+private:
+	std::string atmosphere_;
+	std::string sourceLang_;
+	int counts_;
+	std::vector<std::string> fileUrls_;
+	std::string text_;
+	std::vector<std::string> voices_;
+	std::string appId_;
+	std::string topic_;
+	std::string style_;
+	std::string workspaceId_;
+};
+} // namespace Model
+} // namespace AIPodcast
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIPODCAST_MODEL_PODCASTTASKSUBMITREQUEST_H_

aipodcast/include/alibabacloud/aipodcast/model/PodcastTaskSubmitResult.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_AIPODCAST_MODEL_PODCASTTASKSUBMITRESULT_H_
+#define ALIBABACLOUD_AIPODCAST_MODEL_PODCASTTASKSUBMITRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/aipodcast/AIPodcastExport.h>
+
+namespace AlibabaCloud
+{
+	namespace AIPodcast
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AIPODCAST_EXPORT PodcastTaskSubmitResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string taskId;
+					std::string taskStatus;
+				};
+
+
+				PodcastTaskSubmitResult();
+				explicit PodcastTaskSubmitResult(const std::string &payload);
+				~PodcastTaskSubmitResult();
+				std::string getMessage()const;
+				std::string getRequestId()const;
+				std::string getHttpStatusCode()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string requestId_;
+				std::string httpStatusCode_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AIPODCAST_MODEL_PODCASTTASKSUBMITRESULT_H_

aipodcast/src/AIPodcastClient.cc

@@ -0,0 +1,125 @@
+/*
+ * 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/aipodcast/AIPodcastClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::AIPodcast;
+using namespace AlibabaCloud::AIPodcast::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "AIPodcast";
+}
+
+AIPodcastClient::AIPodcastClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+AIPodcastClient::AIPodcastClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RoaServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+AIPodcastClient::AIPodcastClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+AIPodcastClient::~AIPodcastClient()
+{}
+
+AIPodcastClient::PodcastTaskResultQueryOutcome AIPodcastClient::podcastTaskResultQuery(const PodcastTaskResultQueryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PodcastTaskResultQueryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PodcastTaskResultQueryOutcome(PodcastTaskResultQueryResult(outcome.result()));
+	else
+		return PodcastTaskResultQueryOutcome(outcome.error());
+}
+
+void AIPodcastClient::podcastTaskResultQueryAsync(const PodcastTaskResultQueryRequest& request, const PodcastTaskResultQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, podcastTaskResultQuery(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIPodcastClient::PodcastTaskResultQueryOutcomeCallable AIPodcastClient::podcastTaskResultQueryCallable(const PodcastTaskResultQueryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PodcastTaskResultQueryOutcome()>>(
+			[this, request]()
+			{
+			return this->podcastTaskResultQuery(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AIPodcastClient::PodcastTaskSubmitOutcome AIPodcastClient::podcastTaskSubmit(const PodcastTaskSubmitRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PodcastTaskSubmitOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PodcastTaskSubmitOutcome(PodcastTaskSubmitResult(outcome.result()));
+	else
+		return PodcastTaskSubmitOutcome(outcome.error());
+}
+
+void AIPodcastClient::podcastTaskSubmitAsync(const PodcastTaskSubmitRequest& request, const PodcastTaskSubmitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, podcastTaskSubmit(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIPodcastClient::PodcastTaskSubmitOutcomeCallable AIPodcastClient::podcastTaskSubmitCallable(const PodcastTaskSubmitRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PodcastTaskSubmitOutcome()>>(
+			[this, request]()
+			{
+			return this->podcastTaskSubmit(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

aipodcast/src/model/PodcastTaskResultQueryRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/aipodcast/model/PodcastTaskResultQueryRequest.h>
+
+using AlibabaCloud::AIPodcast::Model::PodcastTaskResultQueryRequest;
+
+PodcastTaskResultQueryRequest::PodcastTaskResultQueryRequest()
+    : RoaServiceRequest("aipodcast", "2025-02-28") {
+  setResourcePath("/podcast/task"};
+  setMethod(HttpRequest::Method::Post);
+}
+
+PodcastTaskResultQueryRequest::~PodcastTaskResultQueryRequest() {}
+
+std::string PodcastTaskResultQueryRequest::getAppId() const {
+  return appId_;
+}
+
+void PodcastTaskResultQueryRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setBodyParameter(std::string("appId"), appId);
+}
+
+std::string PodcastTaskResultQueryRequest::getTaskId() const {
+  return taskId_;
+}
+
+void PodcastTaskResultQueryRequest::setTaskId(const std::string &taskId) {
+  taskId_ = taskId;
+  setBodyParameter(std::string("taskId"), taskId);
+}
+
+std::string PodcastTaskResultQueryRequest::getWorkspaceId() const {
+  return workspaceId_;
+}
+
+void PodcastTaskResultQueryRequest::setWorkspaceId(const std::string &workspaceId) {
+  workspaceId_ = workspaceId;
+  setBodyParameter(std::string("workspaceId"), workspaceId);
+}
+

aipodcast/src/model/PodcastTaskResultQueryResult.cc

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

aipodcast/src/model/PodcastTaskSubmitRequest.cc

@@ -0,0 +1,122 @@
+/*
+ * 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/aipodcast/model/PodcastTaskSubmitRequest.h>
+
+using AlibabaCloud::AIPodcast::Model::PodcastTaskSubmitRequest;
+
+PodcastTaskSubmitRequest::PodcastTaskSubmitRequest()
+    : RoaServiceRequest("aipodcast", "2025-02-28") {
+  setResourcePath("/podcast/task/submit"};
+  setMethod(HttpRequest::Method::Post);
+}
+
+PodcastTaskSubmitRequest::~PodcastTaskSubmitRequest() {}
+
+std::string PodcastTaskSubmitRequest::getAtmosphere() const {
+  return atmosphere_;
+}
+
+void PodcastTaskSubmitRequest::setAtmosphere(const std::string &atmosphere) {
+  atmosphere_ = atmosphere;
+  setBodyParameter(std::string("atmosphere"), atmosphere);
+}
+
+std::string PodcastTaskSubmitRequest::getSourceLang() const {
+  return sourceLang_;
+}
+
+void PodcastTaskSubmitRequest::setSourceLang(const std::string &sourceLang) {
+  sourceLang_ = sourceLang;
+  setBodyParameter(std::string("sourceLang"), sourceLang);
+}
+
+int PodcastTaskSubmitRequest::getCounts() const {
+  return counts_;
+}
+
+void PodcastTaskSubmitRequest::setCounts(int counts) {
+  counts_ = counts;
+  setBodyParameter(std::string("counts"), std::to_string(counts));
+}
+
+std::vector<PodcastTaskSubmitRequest::std::string> PodcastTaskSubmitRequest::getFileUrls() const {
+  return fileUrls_;
+}
+
+void PodcastTaskSubmitRequest::setFileUrls(const std::vector<PodcastTaskSubmitRequest::std::string> &fileUrls) {
+  fileUrls_ = fileUrls;
+  for(int dep1 = 0; dep1 != fileUrls.size(); dep1++) {
+    setBodyParameter(std::string("fileUrls") + "." + std::to_string(dep1 + 1), fileUrls[dep1]);
+  }
+}
+
+std::string PodcastTaskSubmitRequest::getText() const {
+  return text_;
+}
+
+void PodcastTaskSubmitRequest::setText(const std::string &text) {
+  text_ = text;
+  setBodyParameter(std::string("text"), text);
+}
+
+std::vector<PodcastTaskSubmitRequest::std::string> PodcastTaskSubmitRequest::getVoices() const {
+  return voices_;
+}
+
+void PodcastTaskSubmitRequest::setVoices(const std::vector<PodcastTaskSubmitRequest::std::string> &voices) {
+  voices_ = voices;
+  for(int dep1 = 0; dep1 != voices.size(); dep1++) {
+    setBodyParameter(std::string("voices") + "." + std::to_string(dep1 + 1), voices[dep1]);
+  }
+}
+
+std::string PodcastTaskSubmitRequest::getAppId() const {
+  return appId_;
+}
+
+void PodcastTaskSubmitRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setBodyParameter(std::string("appId"), appId);
+}
+
+std::string PodcastTaskSubmitRequest::getTopic() const {
+  return topic_;
+}
+
+void PodcastTaskSubmitRequest::setTopic(const std::string &topic) {
+  topic_ = topic;
+  setBodyParameter(std::string("topic"), topic);
+}
+
+std::string PodcastTaskSubmitRequest::getStyle() const {
+  return style_;
+}
+
+void PodcastTaskSubmitRequest::setStyle(const std::string &style) {
+  style_ = style;
+  setBodyParameter(std::string("style"), style);
+}
+
+std::string PodcastTaskSubmitRequest::getWorkspaceId() const {
+  return workspaceId_;
+}
+
+void PodcastTaskSubmitRequest::setWorkspaceId(const std::string &workspaceId) {
+  workspaceId_ = workspaceId;
+  setBodyParameter(std::string("workspaceId"), workspaceId);
+}
+

aipodcast/src/model/PodcastTaskSubmitResult.cc

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/aipodcast/model/PodcastTaskSubmitResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::AIPodcast;
+using namespace AlibabaCloud::AIPodcast::Model;
+
+PodcastTaskSubmitResult::PodcastTaskSubmitResult() :
+	ServiceResult()
+{}
+
+PodcastTaskSubmitResult::PodcastTaskSubmitResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PodcastTaskSubmitResult::~PodcastTaskSubmitResult()
+{}
+
+void PodcastTaskSubmitResult::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["taskId"].isNull())
+		data_.taskId = dataNode["taskId"].asString();
+	if(!dataNode["taskStatus"].isNull())
+		data_.taskStatus = dataNode["taskStatus"].asString();
+	if(!value["code"].isNull())
+		code_ = value["code"].asString();
+	if(!value["message"].isNull())
+		message_ = value["message"].asString();
+	if(!value["requestId"].isNull())
+		requestId_ = value["requestId"].asString();
+	if(!value["success"].isNull())
+		success_ = value["success"].asString() == "true";
+	if(!value["httpStatusCode"].isNull())
+		httpStatusCode_ = value["httpStatusCode"].asString();
+
+}
+
+std::string PodcastTaskSubmitResult::getMessage()const
+{
+	return message_;
+}
+
+std::string PodcastTaskSubmitResult::getRequestId()const
+{
+	return requestId_;
+}
+
+std::string PodcastTaskSubmitResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+PodcastTaskSubmitResult::Data PodcastTaskSubmitResult::getData()const
+{
+	return data_;
+}
+
+std::string PodcastTaskSubmitResult::getCode()const
+{
+	return code_;
+}
+
+bool PodcastTaskSubmitResult::getSuccess()const
+{
+	return success_;
+}
+

alb/include/alibabacloud/alb/model/CreateListenerRequest.h

@@ -55,6 +55,8 @@ public:
 		std::string xForwardedForClientCertSubjectDNAlias;
 		bool xForwardedForClientSourceIpsEnabled;
 		bool xForwardedForClientCertIssuerDNEnabled;
+		bool xForwardedForHostEnabled;
+		std::string xForwardedForProcessingMode;
 		bool xForwardedForClientCertFingerprintEnabled;
 		std::string xForwardedForClientCertIssuerDNAlias;
 		bool xForwardedForProtoEnabled;

alb/include/alibabacloud/alb/model/CreateServerGroupRequest.h

@@ -70,6 +70,8 @@ public:
 	};
 	CreateServerGroupRequest();
 	~CreateServerGroupRequest();
+	bool getCrossZoneEnabled() const;
+	void setCrossZoneEnabled(bool crossZoneEnabled);
 	std::string getServerGroupName() const;
 	void setServerGroupName(const std::string &serverGroupName);
 	std::string getClientToken() const;
@@ -106,6 +108,7 @@ public:
 	void setUchConfig(const UchConfig &uchConfig);
 
 private:
+	bool crossZoneEnabled_;
 	std::string serverGroupName_;
 	std::string clientToken_;
 	HealthCheckConfig healthCheckConfig_;

alb/include/alibabacloud/alb/model/GetListenerAttributeResult.h

@@ -63,6 +63,7 @@ namespace AlibabaCloud
 					bool xForwardedForClientSourceIpsEnabled;
 					std::string xForwardedForClientCertFingerprintAlias;
 					bool xForwardedForClientCertFingerprintEnabled;
+					bool xForwardedForHostEnabled;
 					std::string xForwardedForClientSourceIpsTrusted;
 					std::string xForwardedForClientCertIssuerDNAlias;
 					std::string xForwardedForClientCertClientVerifyAlias;
@@ -72,6 +73,7 @@ namespace AlibabaCloud
 					bool xForwardedForProtoEnabled;
 					bool xForwardedForClientSrcPortEnabled;
 					bool xForwardedForEnabled;
+					std::string xForwardedForProcessingMode;
 					bool xForwardedForSLBPortEnabled;
 					bool xForwardedForClientCertIssuerDNEnabled;
 					bool xForwardedForClientCertClientVerifyEnabled;

alb/include/alibabacloud/alb/model/ListListenersResult.h

@@ -55,6 +55,7 @@ namespace AlibabaCloud
 						bool xForwardedForClientSourceIpsEnabled;
 						std::string xForwardedForClientCertFingerprintAlias;
 						bool xForwardedForClientCertFingerprintEnabled;
+						bool xForwardedForHostEnabled;
 						std::string xForwardedForClientSourceIpsTrusted;
 						std::string xForwardedForClientCertIssuerDNAlias;
 						std::string xForwardedForClientCertClientVerifyAlias;
@@ -64,6 +65,7 @@ namespace AlibabaCloud
 						bool xForwardedForProtoEnabled;
 						bool xForwardedForClientSrcPortEnabled;
 						bool xForwardedForEnabled;
+						std::string xForwardedForProcessingMode;
 						bool xForwardedForSLBPortEnabled;
 						bool xForwardedForClientCertIssuerDNEnabled;
 						bool xForwardedForClientCertClientVerifyEnabled;

alb/include/alibabacloud/alb/model/ListServerGroupsResult.h

@@ -84,6 +84,7 @@ namespace AlibabaCloud
 					std::string scheduler;
 					std::vector<std::string> relatedRuleIds;
 					int serverCount;
+					bool crossZoneEnabled;
 					bool ipv6Enabled;
 					SlowStartConfig slowStartConfig;
 					std::string serviceManagedMode;

alb/include/alibabacloud/alb/model/UpdateListenerAttributeRequest.h

@@ -51,6 +51,8 @@ public:
 		std::string xForwardedForClientCertSubjectDNAlias;
 		bool xForwardedForClientSourceIpsEnabled;
 		bool xForwardedForClientCertIssuerDNEnabled;
+		bool xForwardedForHostEnabled;
+		std::string xForwardedForProcessingMode;
 		bool xForwardedForClientCertFingerprintEnabled;
 		std::string xForwardedForClientCertIssuerDNAlias;
 		bool xForwardedForProtoEnabled;

alb/include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h

@@ -66,6 +66,8 @@ public:
 	};
 	UpdateServerGroupAttributeRequest();
 	~UpdateServerGroupAttributeRequest();
+	bool getCrossZoneEnabled() const;
+	void setCrossZoneEnabled(bool crossZoneEnabled);
 	std::string getServerGroupName() const;
 	void setServerGroupName(const std::string &serverGroupName);
 	std::string getClientToken() const;
@@ -92,6 +94,7 @@ public:
 	void setUchConfig(const UchConfig &uchConfig);
 
 private:
+	bool crossZoneEnabled_;
 	std::string serverGroupName_;
 	std::string clientToken_;
 	HealthCheckConfig healthCheckConfig_;

alb/src/model/CreateListenerRequest.cc

@@ -136,6 +136,8 @@ void CreateListenerRequest::setXForwardedForConfig(const CreateListenerRequest::
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertSubjectDNAlias", xForwardedForConfig.xForwardedForClientCertSubjectDNAlias);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientSourceIpsEnabled", xForwardedForConfig.xForwardedForClientSourceIpsEnabled ? "true" : "false");
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertIssuerDNEnabled", xForwardedForConfig.xForwardedForClientCertIssuerDNEnabled ? "true" : "false");
+  setParameter(std::string("XForwardedForConfig") + ".XForwardedForHostEnabled", xForwardedForConfig.xForwardedForHostEnabled ? "true" : "false");
+  setParameter(std::string("XForwardedForConfig") + ".XForwardedForProcessingMode", xForwardedForConfig.xForwardedForProcessingMode);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertFingerprintEnabled", xForwardedForConfig.xForwardedForClientCertFingerprintEnabled ? "true" : "false");
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertIssuerDNAlias", xForwardedForConfig.xForwardedForClientCertIssuerDNAlias);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForProtoEnabled", xForwardedForConfig.xForwardedForProtoEnabled ? "true" : "false");

alb/src/model/CreateRulesRequest.cc

@@ -43,92 +43,92 @@ void CreateRulesRequest::setRules(const std::vector<CreateRulesRequest::Rules> &
   for(int dep1 = 0; dep1 != rules.size(); dep1++) {
     for(int dep2 = 0; dep2 != rules[dep1].ruleConditions.size(); dep2++) {
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].methodConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".MethodConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].methodConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".MethodConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].methodConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].sourceIpConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".SourceIpConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].sourceIpConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".SourceIpConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].sourceIpConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].hostConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HostConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].hostConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HostConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].hostConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].queryStringConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].value);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].key);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].value);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].key);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseStatusCodeConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseStatusCodeConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].pathConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".PathConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].pathConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".PathConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].pathConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].cookieConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].value);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].key);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].value);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].key);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleConditions[dep2].type);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleConditions[dep2].type);
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].headerConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].headerConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].headerConfig.values[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Key", rules[dep1].ruleConditions[dep2].headerConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Key", rules[dep1].ruleConditions[dep2].headerConfig.key);
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].responseHeaderConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseHeaderConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseHeaderConfig.values[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Key", rules[dep1].ruleConditions[dep2].responseHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Key", rules[dep1].ruleConditions[dep2].responseHeaderConfig.key);
     }
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleName", rules[dep1].ruleName);
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleName", rules[dep1].ruleName);
     for(int dep2 = 0; dep2 != rules[dep1].tag.size(); dep2++) {
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Tag." + std::to_string(dep2 + 1) + ".Value", rules[dep1].tag[dep2].value);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Tag." + std::to_string(dep2 + 1) + ".Key", rules[dep1].tag[dep2].key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Tag." + std::to_string(dep2 + 1) + ".Value", rules[dep1].tag[dep2].value);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Tag." + std::to_string(dep2 + 1) + ".Key", rules[dep1].tag[dep2].key);
     }
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Priority", std::to_string(rules[dep1].priority));
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Priority", std::to_string(rules[dep1].priority));
     for(int dep2 = 0; dep2 != rules[dep1].ruleActions.size(); dep2++) {
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.HttpCode", rules[dep1].ruleActions[dep2].fixedResponseConfig.httpCode);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.Content", rules[dep1].ruleActions[dep2].fixedResponseConfig.content);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.ContentType", rules[dep1].ruleActions[dep2].fixedResponseConfig.contentType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.HttpCode", rules[dep1].ruleActions[dep2].fixedResponseConfig.httpCode);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.Content", rules[dep1].ruleActions[dep2].fixedResponseConfig.content);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.ContentType", rules[dep1].ruleActions[dep2].fixedResponseConfig.contentType);
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.MirrorGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples[dep3].serverGroupId);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.MirrorGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples[dep3].serverGroupId);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.TargetType", rules[dep1].ruleActions[dep2].trafficMirrorConfig.targetType);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Enabled", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.enabled ? "true" : "false");
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Timeout", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.timeout));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.TargetType", rules[dep1].ruleActions[dep2].trafficMirrorConfig.targetType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Enabled", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.enabled ? "true" : "false");
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Timeout", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.timeout));
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].serverGroupId);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".Weight", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].weight));
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].serverGroupId);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".Weight", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].weight));
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RemoveHeaderConfig.Key", rules[dep1].ruleActions[dep2].removeHeaderConfig.key);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.ValueType", rules[dep1].ruleActions[dep2].insertHeaderConfig.valueType);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.CoverEnabled", rules[dep1].ruleActions[dep2].insertHeaderConfig.coverEnabled ? "true" : "false");
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Value", rules[dep1].ruleActions[dep2].insertHeaderConfig.value);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Key", rules[dep1].ruleActions[dep2].insertHeaderConfig.key);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.QPS", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.qPS));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.PerIpQps", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.perIpQps));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowCredentials", rules[dep1].ruleActions[dep2].corsConfig.allowCredentials);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RemoveHeaderConfig.Key", rules[dep1].ruleActions[dep2].removeHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.ValueType", rules[dep1].ruleActions[dep2].insertHeaderConfig.valueType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.CoverEnabled", rules[dep1].ruleActions[dep2].insertHeaderConfig.coverEnabled ? "true" : "false");
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Value", rules[dep1].ruleActions[dep2].insertHeaderConfig.value);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Key", rules[dep1].ruleActions[dep2].insertHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.QPS", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.qPS));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.PerIpQps", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.perIpQps));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowCredentials", rules[dep1].ruleActions[dep2].corsConfig.allowCredentials);
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowOrigin.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowOrigin." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowOrigin[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowOrigin." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowOrigin[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.MaxAge", std::to_string(rules[dep1].ruleActions[dep2].corsConfig.maxAge));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.MaxAge", std::to_string(rules[dep1].ruleActions[dep2].corsConfig.maxAge));
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowMethods.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowMethods." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowMethods[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowMethods." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowMethods[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowHeaders.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowHeaders[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowHeaders[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.ExposeHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.ExposeHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Path", rules[dep1].ruleActions[dep2].redirectConfig.path);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Protocol", rules[dep1].ruleActions[dep2].redirectConfig.protocol);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Port", rules[dep1].ruleActions[dep2].redirectConfig.port);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Query", rules[dep1].ruleActions[dep2].redirectConfig.query);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Host", rules[dep1].ruleActions[dep2].redirectConfig.host);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.HttpCode", rules[dep1].ruleActions[dep2].redirectConfig.httpCode);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleActions[dep2].type);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Order", std::to_string(rules[dep1].ruleActions[dep2].order));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Path", rules[dep1].ruleActions[dep2].rewriteConfig.path);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Query", rules[dep1].ruleActions[dep2].rewriteConfig.query);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Host", rules[dep1].ruleActions[dep2].rewriteConfig.host);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Path", rules[dep1].ruleActions[dep2].redirectConfig.path);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Protocol", rules[dep1].ruleActions[dep2].redirectConfig.protocol);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Port", rules[dep1].ruleActions[dep2].redirectConfig.port);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Query", rules[dep1].ruleActions[dep2].redirectConfig.query);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Host", rules[dep1].ruleActions[dep2].redirectConfig.host);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.HttpCode", rules[dep1].ruleActions[dep2].redirectConfig.httpCode);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleActions[dep2].type);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Order", std::to_string(rules[dep1].ruleActions[dep2].order));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Path", rules[dep1].ruleActions[dep2].rewriteConfig.path);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Query", rules[dep1].ruleActions[dep2].rewriteConfig.query);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Host", rules[dep1].ruleActions[dep2].rewriteConfig.host);
     }
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Direction", rules[dep1].direction);
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Direction", rules[dep1].direction);
   }
 }
 

alb/src/model/CreateServerGroupRequest.cc

@@ -25,6 +25,15 @@ CreateServerGroupRequest::CreateServerGroupRequest()
 
 CreateServerGroupRequest::~CreateServerGroupRequest() {}
 
+bool CreateServerGroupRequest::getCrossZoneEnabled() const {
+  return crossZoneEnabled_;
+}
+
+void CreateServerGroupRequest::setCrossZoneEnabled(bool crossZoneEnabled) {
+  crossZoneEnabled_ = crossZoneEnabled;
+  setParameter(std::string("CrossZoneEnabled"), crossZoneEnabled ? "true" : "false");
+}
+
 std::string CreateServerGroupRequest::getServerGroupName() const {
   return serverGroupName_;
 }

alb/src/model/GetListenerAttributeResult.cc

@@ -151,6 +151,8 @@ void GetListenerAttributeResult::parse(const std::string &payload)
 		xForwardedForConfig_.xForwardedForClientSrcPortEnabled = xForwardedForConfigNode["XForwardedForClientSrcPortEnabled"].asString() == "true";
 	if(!xForwardedForConfigNode["XForwardedForEnabled"].isNull())
 		xForwardedForConfig_.xForwardedForEnabled = xForwardedForConfigNode["XForwardedForEnabled"].asString() == "true";
+	if(!xForwardedForConfigNode["XForwardedForProcessingMode"].isNull())
+		xForwardedForConfig_.xForwardedForProcessingMode = xForwardedForConfigNode["XForwardedForProcessingMode"].asString();
 	if(!xForwardedForConfigNode["XForwardedForProtoEnabled"].isNull())
 		xForwardedForConfig_.xForwardedForProtoEnabled = xForwardedForConfigNode["XForwardedForProtoEnabled"].asString() == "true";
 	if(!xForwardedForConfigNode["XForwardedForSLBIdEnabled"].isNull())
@@ -161,6 +163,8 @@ void GetListenerAttributeResult::parse(const std::string &payload)
 		xForwardedForConfig_.xForwardedForClientSourceIpsEnabled = xForwardedForConfigNode["XForwardedForClientSourceIpsEnabled"].asString() == "true";
 	if(!xForwardedForConfigNode["XForwardedForClientSourceIpsTrusted"].isNull())
 		xForwardedForConfig_.xForwardedForClientSourceIpsTrusted = xForwardedForConfigNode["XForwardedForClientSourceIpsTrusted"].asString();
+	if(!xForwardedForConfigNode["XForwardedForHostEnabled"].isNull())
+		xForwardedForConfig_.xForwardedForHostEnabled = xForwardedForConfigNode["XForwardedForHostEnabled"].asString() == "true";
 	if(!value["CaEnabled"].isNull())
 		caEnabled_ = value["CaEnabled"].asString() == "true";
 	if(!value["GzipEnabled"].isNull())

alb/src/model/ListListenersResult.cc

@@ -148,6 +148,8 @@ void ListListenersResult::parse(const std::string &payload)
 			listenersObject.xForwardedForConfig.xForwardedForClientSrcPortEnabled = xForwardedForConfigNode["XForwardedForClientSrcPortEnabled"].asString() == "true";
 		if(!xForwardedForConfigNode["XForwardedForEnabled"].isNull())
 			listenersObject.xForwardedForConfig.xForwardedForEnabled = xForwardedForConfigNode["XForwardedForEnabled"].asString() == "true";
+		if(!xForwardedForConfigNode["XForwardedForProcessingMode"].isNull())
+			listenersObject.xForwardedForConfig.xForwardedForProcessingMode = xForwardedForConfigNode["XForwardedForProcessingMode"].asString();
 		if(!xForwardedForConfigNode["XForwardedForProtoEnabled"].isNull())
 			listenersObject.xForwardedForConfig.xForwardedForProtoEnabled = xForwardedForConfigNode["XForwardedForProtoEnabled"].asString() == "true";
 		if(!xForwardedForConfigNode["XForwardedForSLBIdEnabled"].isNull())
@@ -158,6 +160,8 @@ void ListListenersResult::parse(const std::string &payload)
 			listenersObject.xForwardedForConfig.xForwardedForClientSourceIpsEnabled = xForwardedForConfigNode["XForwardedForClientSourceIpsEnabled"].asString() == "true";
 		if(!xForwardedForConfigNode["XForwardedForClientSourceIpsTrusted"].isNull())
 			listenersObject.xForwardedForConfig.xForwardedForClientSourceIpsTrusted = xForwardedForConfigNode["XForwardedForClientSourceIpsTrusted"].asString();
+		if(!xForwardedForConfigNode["XForwardedForHostEnabled"].isNull())
+			listenersObject.xForwardedForConfig.xForwardedForHostEnabled = xForwardedForConfigNode["XForwardedForHostEnabled"].asString() == "true";
 		listeners_.push_back(listenersObject);
 	}
 	if(!value["MaxResults"].isNull())

alb/src/model/ListServerGroupsResult.cc

@@ -75,6 +75,8 @@ void ListServerGroupsResult::parse(const std::string &payload)
 			serverGroupsObject.serviceName = valueServerGroupsServerGroup["ServiceName"].asString();
 		if(!valueServerGroupsServerGroup["CreateTime"].isNull())
 			serverGroupsObject.createTime = valueServerGroupsServerGroup["CreateTime"].asString();
+		if(!valueServerGroupsServerGroup["CrossZoneEnabled"].isNull())
+			serverGroupsObject.crossZoneEnabled = valueServerGroupsServerGroup["CrossZoneEnabled"].asString() == "true";
 		auto allTagsNode = valueServerGroupsServerGroup["Tags"]["Tag"];
 		for (auto valueServerGroupsServerGroupTagsTag : allTagsNode)
 		{

alb/src/model/UpdateListenerAttributeRequest.cc

@@ -124,6 +124,8 @@ void UpdateListenerAttributeRequest::setXForwardedForConfig(const UpdateListener
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertSubjectDNAlias", xForwardedForConfig.xForwardedForClientCertSubjectDNAlias);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientSourceIpsEnabled", xForwardedForConfig.xForwardedForClientSourceIpsEnabled ? "true" : "false");
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertIssuerDNEnabled", xForwardedForConfig.xForwardedForClientCertIssuerDNEnabled ? "true" : "false");
+  setParameter(std::string("XForwardedForConfig") + ".XForwardedForHostEnabled", xForwardedForConfig.xForwardedForHostEnabled ? "true" : "false");
+  setParameter(std::string("XForwardedForConfig") + ".XForwardedForProcessingMode", xForwardedForConfig.xForwardedForProcessingMode);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertFingerprintEnabled", xForwardedForConfig.xForwardedForClientCertFingerprintEnabled ? "true" : "false");
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertIssuerDNAlias", xForwardedForConfig.xForwardedForClientCertIssuerDNAlias);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForProtoEnabled", xForwardedForConfig.xForwardedForProtoEnabled ? "true" : "false");

alb/src/model/UpdateRulesAttributeRequest.cc

@@ -43,87 +43,87 @@ void UpdateRulesAttributeRequest::setRules(const std::vector<UpdateRulesAttribut
   for(int dep1 = 0; dep1 != rules.size(); dep1++) {
     for(int dep2 = 0; dep2 != rules[dep1].ruleConditions.size(); dep2++) {
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].methodConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".MethodConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].methodConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".MethodConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].methodConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].sourceIpConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".SourceIpConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].sourceIpConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".SourceIpConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].sourceIpConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].hostConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HostConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].hostConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HostConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].hostConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].queryStringConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].value);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].key);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].value);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].key);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseStatusCodeConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseStatusCodeConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].pathConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".PathConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].pathConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".PathConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].pathConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].cookieConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].value);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].key);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].value);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].key);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleConditions[dep2].type);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleConditions[dep2].type);
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].headerConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].headerConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].headerConfig.values[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Key", rules[dep1].ruleConditions[dep2].headerConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Key", rules[dep1].ruleConditions[dep2].headerConfig.key);
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].responseHeaderConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseHeaderConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseHeaderConfig.values[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Key", rules[dep1].ruleConditions[dep2].responseHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Key", rules[dep1].ruleConditions[dep2].responseHeaderConfig.key);
     }
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleName", rules[dep1].ruleName);
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Priority", std::to_string(rules[dep1].priority));
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleId", rules[dep1].ruleId);
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleName", rules[dep1].ruleName);
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Priority", std::to_string(rules[dep1].priority));
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleId", rules[dep1].ruleId);
     for(int dep2 = 0; dep2 != rules[dep1].ruleActions.size(); dep2++) {
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.HttpCode", rules[dep1].ruleActions[dep2].fixedResponseConfig.httpCode);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.Content", rules[dep1].ruleActions[dep2].fixedResponseConfig.content);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.ContentType", rules[dep1].ruleActions[dep2].fixedResponseConfig.contentType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.HttpCode", rules[dep1].ruleActions[dep2].fixedResponseConfig.httpCode);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.Content", rules[dep1].ruleActions[dep2].fixedResponseConfig.content);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.ContentType", rules[dep1].ruleActions[dep2].fixedResponseConfig.contentType);
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.MirrorGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples[dep3].serverGroupId);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.MirrorGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples[dep3].serverGroupId);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.TargetType", rules[dep1].ruleActions[dep2].trafficMirrorConfig.targetType);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Enabled", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.enabled ? "true" : "false");
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Timeout", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.timeout));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.TargetType", rules[dep1].ruleActions[dep2].trafficMirrorConfig.targetType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Enabled", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.enabled ? "true" : "false");
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Timeout", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.timeout));
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].serverGroupId);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".Weight", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].weight));
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].serverGroupId);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".Weight", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].weight));
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RemoveHeaderConfig.Key", rules[dep1].ruleActions[dep2].removeHeaderConfig.key);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.ValueType", rules[dep1].ruleActions[dep2].insertHeaderConfig.valueType);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.CoverEnabled", rules[dep1].ruleActions[dep2].insertHeaderConfig.coverEnabled ? "true" : "false");
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Value", rules[dep1].ruleActions[dep2].insertHeaderConfig.value);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Key", rules[dep1].ruleActions[dep2].insertHeaderConfig.key);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.QPS", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.qPS));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.PerIpQps", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.perIpQps));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowCredentials", rules[dep1].ruleActions[dep2].corsConfig.allowCredentials);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RemoveHeaderConfig.Key", rules[dep1].ruleActions[dep2].removeHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.ValueType", rules[dep1].ruleActions[dep2].insertHeaderConfig.valueType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.CoverEnabled", rules[dep1].ruleActions[dep2].insertHeaderConfig.coverEnabled ? "true" : "false");
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Value", rules[dep1].ruleActions[dep2].insertHeaderConfig.value);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Key", rules[dep1].ruleActions[dep2].insertHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.QPS", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.qPS));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.PerIpQps", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.perIpQps));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowCredentials", rules[dep1].ruleActions[dep2].corsConfig.allowCredentials);
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowOrigin.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowOrigin." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowOrigin[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowOrigin." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowOrigin[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.MaxAge", std::to_string(rules[dep1].ruleActions[dep2].corsConfig.maxAge));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.MaxAge", std::to_string(rules[dep1].ruleActions[dep2].corsConfig.maxAge));
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowMethods.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowMethods." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowMethods[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowMethods." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowMethods[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowHeaders.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowHeaders[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowHeaders[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.ExposeHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.ExposeHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Path", rules[dep1].ruleActions[dep2].redirectConfig.path);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Protocol", rules[dep1].ruleActions[dep2].redirectConfig.protocol);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Port", rules[dep1].ruleActions[dep2].redirectConfig.port);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Query", rules[dep1].ruleActions[dep2].redirectConfig.query);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Host", rules[dep1].ruleActions[dep2].redirectConfig.host);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.HttpCode", rules[dep1].ruleActions[dep2].redirectConfig.httpCode);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleActions[dep2].type);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Order", std::to_string(rules[dep1].ruleActions[dep2].order));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Path", rules[dep1].ruleActions[dep2].rewriteConfig.path);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Query", rules[dep1].ruleActions[dep2].rewriteConfig.query);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Host", rules[dep1].ruleActions[dep2].rewriteConfig.host);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Path", rules[dep1].ruleActions[dep2].redirectConfig.path);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Protocol", rules[dep1].ruleActions[dep2].redirectConfig.protocol);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Port", rules[dep1].ruleActions[dep2].redirectConfig.port);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Query", rules[dep1].ruleActions[dep2].redirectConfig.query);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Host", rules[dep1].ruleActions[dep2].redirectConfig.host);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.HttpCode", rules[dep1].ruleActions[dep2].redirectConfig.httpCode);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleActions[dep2].type);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Order", std::to_string(rules[dep1].ruleActions[dep2].order));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Path", rules[dep1].ruleActions[dep2].rewriteConfig.path);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Query", rules[dep1].ruleActions[dep2].rewriteConfig.query);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Host", rules[dep1].ruleActions[dep2].rewriteConfig.host);
     }
   }
 }

alb/src/model/UpdateServerGroupAttributeRequest.cc

@@ -25,6 +25,15 @@ UpdateServerGroupAttributeRequest::UpdateServerGroupAttributeRequest()
 
 UpdateServerGroupAttributeRequest::~UpdateServerGroupAttributeRequest() {}
 
+bool UpdateServerGroupAttributeRequest::getCrossZoneEnabled() const {
+  return crossZoneEnabled_;
+}
+
+void UpdateServerGroupAttributeRequest::setCrossZoneEnabled(bool crossZoneEnabled) {
+  crossZoneEnabled_ = crossZoneEnabled;
+  setParameter(std::string("CrossZoneEnabled"), crossZoneEnabled ? "true" : "false");
+}
+
 std::string UpdateServerGroupAttributeRequest::getServerGroupName() const {
   return serverGroupName_;
 }

clickhouse/CMakeLists.txt

@@ -0,0 +1,334 @@
+#
+# 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(clickhouse_public_header 
+	include/alibabacloud/clickhouse/ClickhouseClient.h
+	include/alibabacloud/clickhouse/ClickhouseExport.h )
+
+set(clickhouse_public_header_model 
+	include/alibabacloud/clickhouse/model/AllocateClusterPublicConnectionRequest.h
+	include/alibabacloud/clickhouse/model/AllocateClusterPublicConnectionResult.h
+	include/alibabacloud/clickhouse/model/CheckClickhouseToRDSRequest.h
+	include/alibabacloud/clickhouse/model/CheckClickhouseToRDSResult.h
+	include/alibabacloud/clickhouse/model/CheckModifyConfigNeedRestartRequest.h
+	include/alibabacloud/clickhouse/model/CheckModifyConfigNeedRestartResult.h
+	include/alibabacloud/clickhouse/model/CheckMonitorAlertRequest.h
+	include/alibabacloud/clickhouse/model/CheckMonitorAlertResult.h
+	include/alibabacloud/clickhouse/model/CheckScaleOutBalancedRequest.h
+	include/alibabacloud/clickhouse/model/CheckScaleOutBalancedResult.h
+	include/alibabacloud/clickhouse/model/CheckServiceLinkedRoleRequest.h
+	include/alibabacloud/clickhouse/model/CheckServiceLinkedRoleResult.h
+	include/alibabacloud/clickhouse/model/CreateAccountRequest.h
+	include/alibabacloud/clickhouse/model/CreateAccountResult.h
+	include/alibabacloud/clickhouse/model/CreateAccountAndAuthorityRequest.h
+	include/alibabacloud/clickhouse/model/CreateAccountAndAuthorityResult.h
+	include/alibabacloud/clickhouse/model/CreateBackupPolicyRequest.h
+	include/alibabacloud/clickhouse/model/CreateBackupPolicyResult.h
+	include/alibabacloud/clickhouse/model/CreateDBInstanceRequest.h
+	include/alibabacloud/clickhouse/model/CreateDBInstanceResult.h
+	include/alibabacloud/clickhouse/model/CreateMonitorDataReportRequest.h
+	include/alibabacloud/clickhouse/model/CreateMonitorDataReportResult.h
+	include/alibabacloud/clickhouse/model/CreateOSSStorageRequest.h
+	include/alibabacloud/clickhouse/model/CreateOSSStorageResult.h
+	include/alibabacloud/clickhouse/model/CreatePortsForClickHouseRequest.h
+	include/alibabacloud/clickhouse/model/CreatePortsForClickHouseResult.h
+	include/alibabacloud/clickhouse/model/CreateRDSToClickhouseDbRequest.h
+	include/alibabacloud/clickhouse/model/CreateRDSToClickhouseDbResult.h
+	include/alibabacloud/clickhouse/model/CreateSQLAccountRequest.h
+	include/alibabacloud/clickhouse/model/CreateSQLAccountResult.h
+	include/alibabacloud/clickhouse/model/CreateServiceLinkedRoleRequest.h
+	include/alibabacloud/clickhouse/model/CreateServiceLinkedRoleResult.h
+	include/alibabacloud/clickhouse/model/DeleteAccountRequest.h
+	include/alibabacloud/clickhouse/model/DeleteAccountResult.h
+	include/alibabacloud/clickhouse/model/DeleteDBClusterRequest.h
+	include/alibabacloud/clickhouse/model/DeleteDBClusterResult.h
+	include/alibabacloud/clickhouse/model/DeleteSyndbRequest.h
+	include/alibabacloud/clickhouse/model/DeleteSyndbResult.h
+	include/alibabacloud/clickhouse/model/DescribeAccountAuthorityRequest.h
+	include/alibabacloud/clickhouse/model/DescribeAccountAuthorityResult.h
+	include/alibabacloud/clickhouse/model/DescribeAccountsRequest.h
+	include/alibabacloud/clickhouse/model/DescribeAccountsResult.h
+	include/alibabacloud/clickhouse/model/DescribeAllDataSourceRequest.h
+	include/alibabacloud/clickhouse/model/DescribeAllDataSourceResult.h
+	include/alibabacloud/clickhouse/model/DescribeAllDataSourcesRequest.h
+	include/alibabacloud/clickhouse/model/DescribeAllDataSourcesResult.h
+	include/alibabacloud/clickhouse/model/DescribeBackupPolicyRequest.h
+	include/alibabacloud/clickhouse/model/DescribeBackupPolicyResult.h
+	include/alibabacloud/clickhouse/model/DescribeBackupsRequest.h
+	include/alibabacloud/clickhouse/model/DescribeBackupsResult.h
+	include/alibabacloud/clickhouse/model/DescribeColumnsRequest.h
+	include/alibabacloud/clickhouse/model/DescribeColumnsResult.h
+	include/alibabacloud/clickhouse/model/DescribeConfigHistoryRequest.h
+	include/alibabacloud/clickhouse/model/DescribeConfigHistoryResult.h
+	include/alibabacloud/clickhouse/model/DescribeConfigVersionDifferenceRequest.h
+	include/alibabacloud/clickhouse/model/DescribeConfigVersionDifferenceResult.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterAccessWhiteListRequest.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterAccessWhiteListResult.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterAttributeRequest.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterAttributeResult.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterConfigRequest.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterConfigResult.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterConfigInXMLRequest.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterConfigInXMLResult.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterNetInfoItemsRequest.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterNetInfoItemsResult.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterPerformanceRequest.h
+	include/alibabacloud/clickhouse/model/DescribeDBClusterPerformanceResult.h
+	include/alibabacloud/clickhouse/model/DescribeDBClustersRequest.h
+	include/alibabacloud/clickhouse/model/DescribeDBClustersResult.h
+	include/alibabacloud/clickhouse/model/DescribeDBConfigRequest.h
+	include/alibabacloud/clickhouse/model/DescribeDBConfigResult.h
+	include/alibabacloud/clickhouse/model/DescribeOSSStorageRequest.h
+	include/alibabacloud/clickhouse/model/DescribeOSSStorageResult.h
+	include/alibabacloud/clickhouse/model/DescribeProcessListRequest.h
+	include/alibabacloud/clickhouse/model/DescribeProcessListResult.h
+	include/alibabacloud/clickhouse/model/DescribeRegionsRequest.h
+	include/alibabacloud/clickhouse/model/DescribeRegionsResult.h
+	include/alibabacloud/clickhouse/model/DescribeSchemasRequest.h
+	include/alibabacloud/clickhouse/model/DescribeSchemasResult.h
+	include/alibabacloud/clickhouse/model/DescribeSlowLogRecordsRequest.h
+	include/alibabacloud/clickhouse/model/DescribeSlowLogRecordsResult.h
+	include/alibabacloud/clickhouse/model/DescribeSynDbTablesRequest.h
+	include/alibabacloud/clickhouse/model/DescribeSynDbTablesResult.h
+	include/alibabacloud/clickhouse/model/DescribeSynDbsRequest.h
+	include/alibabacloud/clickhouse/model/DescribeSynDbsResult.h
+	include/alibabacloud/clickhouse/model/DescribeTablesRequest.h
+	include/alibabacloud/clickhouse/model/DescribeTablesResult.h
+	include/alibabacloud/clickhouse/model/DescribeTransferHistoryRequest.h
+	include/alibabacloud/clickhouse/model/DescribeTransferHistoryResult.h
+	include/alibabacloud/clickhouse/model/KillProcessRequest.h
+	include/alibabacloud/clickhouse/model/KillProcessResult.h
+	include/alibabacloud/clickhouse/model/ModifyAccountAuthorityRequest.h
+	include/alibabacloud/clickhouse/model/ModifyAccountAuthorityResult.h
+	include/alibabacloud/clickhouse/model/ModifyAccountDescriptionRequest.h
+	include/alibabacloud/clickhouse/model/ModifyAccountDescriptionResult.h
+	include/alibabacloud/clickhouse/model/ModifyBackupPolicyRequest.h
+	include/alibabacloud/clickhouse/model/ModifyBackupPolicyResult.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterRequest.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterResult.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterAccessWhiteListRequest.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterAccessWhiteListResult.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterConfigRequest.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterConfigResult.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterConfigInXMLRequest.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterConfigInXMLResult.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterDescriptionRequest.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterDescriptionResult.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterMaintainTimeRequest.h
+	include/alibabacloud/clickhouse/model/ModifyDBClusterMaintainTimeResult.h
+	include/alibabacloud/clickhouse/model/ModifyDBConfigRequest.h
+	include/alibabacloud/clickhouse/model/ModifyDBConfigResult.h
+	include/alibabacloud/clickhouse/model/ModifyMinorVersionGreadeTypeRequest.h
+	include/alibabacloud/clickhouse/model/ModifyMinorVersionGreadeTypeResult.h
+	include/alibabacloud/clickhouse/model/ModifyRDSToClickhouseDbRequest.h
+	include/alibabacloud/clickhouse/model/ModifyRDSToClickhouseDbResult.h
+	include/alibabacloud/clickhouse/model/ReleaseClusterPublicConnectionRequest.h
+	include/alibabacloud/clickhouse/model/ReleaseClusterPublicConnectionResult.h
+	include/alibabacloud/clickhouse/model/ResetAccountPasswordRequest.h
+	include/alibabacloud/clickhouse/model/ResetAccountPasswordResult.h
+	include/alibabacloud/clickhouse/model/RestartInstanceRequest.h
+	include/alibabacloud/clickhouse/model/RestartInstanceResult.h
+	include/alibabacloud/clickhouse/model/TransferVersionRequest.h
+	include/alibabacloud/clickhouse/model/TransferVersionResult.h
+	include/alibabacloud/clickhouse/model/UpgradeMinorVersionRequest.h
+	include/alibabacloud/clickhouse/model/UpgradeMinorVersionResult.h )
+
+set(clickhouse_src 
+	src/ClickhouseClient.cc
+	src/model/AllocateClusterPublicConnectionRequest.cc
+	src/model/AllocateClusterPublicConnectionResult.cc
+	src/model/CheckClickhouseToRDSRequest.cc
+	src/model/CheckClickhouseToRDSResult.cc
+	src/model/CheckModifyConfigNeedRestartRequest.cc
+	src/model/CheckModifyConfigNeedRestartResult.cc
+	src/model/CheckMonitorAlertRequest.cc
+	src/model/CheckMonitorAlertResult.cc
+	src/model/CheckScaleOutBalancedRequest.cc
+	src/model/CheckScaleOutBalancedResult.cc
+	src/model/CheckServiceLinkedRoleRequest.cc
+	src/model/CheckServiceLinkedRoleResult.cc
+	src/model/CreateAccountRequest.cc
+	src/model/CreateAccountResult.cc
+	src/model/CreateAccountAndAuthorityRequest.cc
+	src/model/CreateAccountAndAuthorityResult.cc
+	src/model/CreateBackupPolicyRequest.cc
+	src/model/CreateBackupPolicyResult.cc
+	src/model/CreateDBInstanceRequest.cc
+	src/model/CreateDBInstanceResult.cc
+	src/model/CreateMonitorDataReportRequest.cc
+	src/model/CreateMonitorDataReportResult.cc
+	src/model/CreateOSSStorageRequest.cc
+	src/model/CreateOSSStorageResult.cc
+	src/model/CreatePortsForClickHouseRequest.cc
+	src/model/CreatePortsForClickHouseResult.cc
+	src/model/CreateRDSToClickhouseDbRequest.cc
+	src/model/CreateRDSToClickhouseDbResult.cc
+	src/model/CreateSQLAccountRequest.cc
+	src/model/CreateSQLAccountResult.cc
+	src/model/CreateServiceLinkedRoleRequest.cc
+	src/model/CreateServiceLinkedRoleResult.cc
+	src/model/DeleteAccountRequest.cc
+	src/model/DeleteAccountResult.cc
+	src/model/DeleteDBClusterRequest.cc
+	src/model/DeleteDBClusterResult.cc
+	src/model/DeleteSyndbRequest.cc
+	src/model/DeleteSyndbResult.cc
+	src/model/DescribeAccountAuthorityRequest.cc
+	src/model/DescribeAccountAuthorityResult.cc
+	src/model/DescribeAccountsRequest.cc
+	src/model/DescribeAccountsResult.cc
+	src/model/DescribeAllDataSourceRequest.cc
+	src/model/DescribeAllDataSourceResult.cc
+	src/model/DescribeAllDataSourcesRequest.cc
+	src/model/DescribeAllDataSourcesResult.cc
+	src/model/DescribeBackupPolicyRequest.cc
+	src/model/DescribeBackupPolicyResult.cc
+	src/model/DescribeBackupsRequest.cc
+	src/model/DescribeBackupsResult.cc
+	src/model/DescribeColumnsRequest.cc
+	src/model/DescribeColumnsResult.cc
+	src/model/DescribeConfigHistoryRequest.cc
+	src/model/DescribeConfigHistoryResult.cc
+	src/model/DescribeConfigVersionDifferenceRequest.cc
+	src/model/DescribeConfigVersionDifferenceResult.cc
+	src/model/DescribeDBClusterAccessWhiteListRequest.cc
+	src/model/DescribeDBClusterAccessWhiteListResult.cc
+	src/model/DescribeDBClusterAttributeRequest.cc
+	src/model/DescribeDBClusterAttributeResult.cc
+	src/model/DescribeDBClusterConfigRequest.cc
+	src/model/DescribeDBClusterConfigResult.cc
+	src/model/DescribeDBClusterConfigInXMLRequest.cc
+	src/model/DescribeDBClusterConfigInXMLResult.cc
+	src/model/DescribeDBClusterNetInfoItemsRequest.cc
+	src/model/DescribeDBClusterNetInfoItemsResult.cc
+	src/model/DescribeDBClusterPerformanceRequest.cc
+	src/model/DescribeDBClusterPerformanceResult.cc
+	src/model/DescribeDBClustersRequest.cc
+	src/model/DescribeDBClustersResult.cc
+	src/model/DescribeDBConfigRequest.cc
+	src/model/DescribeDBConfigResult.cc
+	src/model/DescribeOSSStorageRequest.cc
+	src/model/DescribeOSSStorageResult.cc
+	src/model/DescribeProcessListRequest.cc
+	src/model/DescribeProcessListResult.cc
+	src/model/DescribeRegionsRequest.cc
+	src/model/DescribeRegionsResult.cc
+	src/model/DescribeSchemasRequest.cc
+	src/model/DescribeSchemasResult.cc
+	src/model/DescribeSlowLogRecordsRequest.cc
+	src/model/DescribeSlowLogRecordsResult.cc
+	src/model/DescribeSynDbTablesRequest.cc
+	src/model/DescribeSynDbTablesResult.cc
+	src/model/DescribeSynDbsRequest.cc
+	src/model/DescribeSynDbsResult.cc
+	src/model/DescribeTablesRequest.cc
+	src/model/DescribeTablesResult.cc
+	src/model/DescribeTransferHistoryRequest.cc
+	src/model/DescribeTransferHistoryResult.cc
+	src/model/KillProcessRequest.cc
+	src/model/KillProcessResult.cc
+	src/model/ModifyAccountAuthorityRequest.cc
+	src/model/ModifyAccountAuthorityResult.cc
+	src/model/ModifyAccountDescriptionRequest.cc
+	src/model/ModifyAccountDescriptionResult.cc
+	src/model/ModifyBackupPolicyRequest.cc
+	src/model/ModifyBackupPolicyResult.cc
+	src/model/ModifyDBClusterRequest.cc
+	src/model/ModifyDBClusterResult.cc
+	src/model/ModifyDBClusterAccessWhiteListRequest.cc
+	src/model/ModifyDBClusterAccessWhiteListResult.cc
+	src/model/ModifyDBClusterConfigRequest.cc
+	src/model/ModifyDBClusterConfigResult.cc
+	src/model/ModifyDBClusterConfigInXMLRequest.cc
+	src/model/ModifyDBClusterConfigInXMLResult.cc
+	src/model/ModifyDBClusterDescriptionRequest.cc
+	src/model/ModifyDBClusterDescriptionResult.cc
+	src/model/ModifyDBClusterMaintainTimeRequest.cc
+	src/model/ModifyDBClusterMaintainTimeResult.cc
+	src/model/ModifyDBConfigRequest.cc
+	src/model/ModifyDBConfigResult.cc
+	src/model/ModifyMinorVersionGreadeTypeRequest.cc
+	src/model/ModifyMinorVersionGreadeTypeResult.cc
+	src/model/ModifyRDSToClickhouseDbRequest.cc
+	src/model/ModifyRDSToClickhouseDbResult.cc
+	src/model/ReleaseClusterPublicConnectionRequest.cc
+	src/model/ReleaseClusterPublicConnectionResult.cc
+	src/model/ResetAccountPasswordRequest.cc
+	src/model/ResetAccountPasswordResult.cc
+	src/model/RestartInstanceRequest.cc
+	src/model/RestartInstanceResult.cc
+	src/model/TransferVersionRequest.cc
+	src/model/TransferVersionResult.cc
+	src/model/UpgradeMinorVersionRequest.cc
+	src/model/UpgradeMinorVersionResult.cc )
+
+add_library(clickhouse ${LIB_TYPE}
+	${clickhouse_public_header}
+	${clickhouse_public_header_model}
+	${clickhouse_src})
+
+set_target_properties(clickhouse
+	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}clickhouse
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(clickhouse
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_CLICKHOUSE_LIBRARY)
+endif()
+
+target_include_directories(clickhouse
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(clickhouse
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(clickhouse
+		jsoncpp)
+	target_include_directories(clickhouse
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(clickhouse
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(clickhouse
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(clickhouse
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(clickhouse
+		jsoncpp)
+endif()
+
+install(FILES ${clickhouse_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/clickhouse)
+install(FILES ${clickhouse_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/clickhouse/model)
+install(TARGETS clickhouse
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

clickhouse/include/alibabacloud/clickhouse/ClickhouseClient.h

@@ -0,0 +1,550 @@
+/*
+ * 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_CLICKHOUSE_CLICKHOUSECLIENT_H_
+#define ALIBABACLOUD_CLICKHOUSE_CLICKHOUSECLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ClickhouseExport.h"
+#include "model/AllocateClusterPublicConnectionRequest.h"
+#include "model/AllocateClusterPublicConnectionResult.h"
+#include "model/CheckClickhouseToRDSRequest.h"
+#include "model/CheckClickhouseToRDSResult.h"
+#include "model/CheckModifyConfigNeedRestartRequest.h"
+#include "model/CheckModifyConfigNeedRestartResult.h"
+#include "model/CheckMonitorAlertRequest.h"
+#include "model/CheckMonitorAlertResult.h"
+#include "model/CheckScaleOutBalancedRequest.h"
+#include "model/CheckScaleOutBalancedResult.h"
+#include "model/CheckServiceLinkedRoleRequest.h"
+#include "model/CheckServiceLinkedRoleResult.h"
+#include "model/CreateAccountRequest.h"
+#include "model/CreateAccountResult.h"
+#include "model/CreateAccountAndAuthorityRequest.h"
+#include "model/CreateAccountAndAuthorityResult.h"
+#include "model/CreateBackupPolicyRequest.h"
+#include "model/CreateBackupPolicyResult.h"
+#include "model/CreateDBInstanceRequest.h"
+#include "model/CreateDBInstanceResult.h"
+#include "model/CreateMonitorDataReportRequest.h"
+#include "model/CreateMonitorDataReportResult.h"
+#include "model/CreateOSSStorageRequest.h"
+#include "model/CreateOSSStorageResult.h"
+#include "model/CreatePortsForClickHouseRequest.h"
+#include "model/CreatePortsForClickHouseResult.h"
+#include "model/CreateRDSToClickhouseDbRequest.h"
+#include "model/CreateRDSToClickhouseDbResult.h"
+#include "model/CreateSQLAccountRequest.h"
+#include "model/CreateSQLAccountResult.h"
+#include "model/CreateServiceLinkedRoleRequest.h"
+#include "model/CreateServiceLinkedRoleResult.h"
+#include "model/DeleteAccountRequest.h"
+#include "model/DeleteAccountResult.h"
+#include "model/DeleteDBClusterRequest.h"
+#include "model/DeleteDBClusterResult.h"
+#include "model/DeleteSyndbRequest.h"
+#include "model/DeleteSyndbResult.h"
+#include "model/DescribeAccountAuthorityRequest.h"
+#include "model/DescribeAccountAuthorityResult.h"
+#include "model/DescribeAccountsRequest.h"
+#include "model/DescribeAccountsResult.h"
+#include "model/DescribeAllDataSourceRequest.h"
+#include "model/DescribeAllDataSourceResult.h"
+#include "model/DescribeAllDataSourcesRequest.h"
+#include "model/DescribeAllDataSourcesResult.h"
+#include "model/DescribeBackupPolicyRequest.h"
+#include "model/DescribeBackupPolicyResult.h"
+#include "model/DescribeBackupsRequest.h"
+#include "model/DescribeBackupsResult.h"
+#include "model/DescribeColumnsRequest.h"
+#include "model/DescribeColumnsResult.h"
+#include "model/DescribeConfigHistoryRequest.h"
+#include "model/DescribeConfigHistoryResult.h"
+#include "model/DescribeConfigVersionDifferenceRequest.h"
+#include "model/DescribeConfigVersionDifferenceResult.h"
+#include "model/DescribeDBClusterAccessWhiteListRequest.h"
+#include "model/DescribeDBClusterAccessWhiteListResult.h"
+#include "model/DescribeDBClusterAttributeRequest.h"
+#include "model/DescribeDBClusterAttributeResult.h"
+#include "model/DescribeDBClusterConfigRequest.h"
+#include "model/DescribeDBClusterConfigResult.h"
+#include "model/DescribeDBClusterConfigInXMLRequest.h"
+#include "model/DescribeDBClusterConfigInXMLResult.h"
+#include "model/DescribeDBClusterNetInfoItemsRequest.h"
+#include "model/DescribeDBClusterNetInfoItemsResult.h"
+#include "model/DescribeDBClusterPerformanceRequest.h"
+#include "model/DescribeDBClusterPerformanceResult.h"
+#include "model/DescribeDBClustersRequest.h"
+#include "model/DescribeDBClustersResult.h"
+#include "model/DescribeDBConfigRequest.h"
+#include "model/DescribeDBConfigResult.h"
+#include "model/DescribeOSSStorageRequest.h"
+#include "model/DescribeOSSStorageResult.h"
+#include "model/DescribeProcessListRequest.h"
+#include "model/DescribeProcessListResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/DescribeSchemasRequest.h"
+#include "model/DescribeSchemasResult.h"
+#include "model/DescribeSlowLogRecordsRequest.h"
+#include "model/DescribeSlowLogRecordsResult.h"
+#include "model/DescribeSynDbTablesRequest.h"
+#include "model/DescribeSynDbTablesResult.h"
+#include "model/DescribeSynDbsRequest.h"
+#include "model/DescribeSynDbsResult.h"
+#include "model/DescribeTablesRequest.h"
+#include "model/DescribeTablesResult.h"
+#include "model/DescribeTransferHistoryRequest.h"
+#include "model/DescribeTransferHistoryResult.h"
+#include "model/KillProcessRequest.h"
+#include "model/KillProcessResult.h"
+#include "model/ModifyAccountAuthorityRequest.h"
+#include "model/ModifyAccountAuthorityResult.h"
+#include "model/ModifyAccountDescriptionRequest.h"
+#include "model/ModifyAccountDescriptionResult.h"
+#include "model/ModifyBackupPolicyRequest.h"
+#include "model/ModifyBackupPolicyResult.h"
+#include "model/ModifyDBClusterRequest.h"
+#include "model/ModifyDBClusterResult.h"
+#include "model/ModifyDBClusterAccessWhiteListRequest.h"
+#include "model/ModifyDBClusterAccessWhiteListResult.h"
+#include "model/ModifyDBClusterConfigRequest.h"
+#include "model/ModifyDBClusterConfigResult.h"
+#include "model/ModifyDBClusterConfigInXMLRequest.h"
+#include "model/ModifyDBClusterConfigInXMLResult.h"
+#include "model/ModifyDBClusterDescriptionRequest.h"
+#include "model/ModifyDBClusterDescriptionResult.h"
+#include "model/ModifyDBClusterMaintainTimeRequest.h"
+#include "model/ModifyDBClusterMaintainTimeResult.h"
+#include "model/ModifyDBConfigRequest.h"
+#include "model/ModifyDBConfigResult.h"
+#include "model/ModifyMinorVersionGreadeTypeRequest.h"
+#include "model/ModifyMinorVersionGreadeTypeResult.h"
+#include "model/ModifyRDSToClickhouseDbRequest.h"
+#include "model/ModifyRDSToClickhouseDbResult.h"
+#include "model/ReleaseClusterPublicConnectionRequest.h"
+#include "model/ReleaseClusterPublicConnectionResult.h"
+#include "model/ResetAccountPasswordRequest.h"
+#include "model/ResetAccountPasswordResult.h"
+#include "model/RestartInstanceRequest.h"
+#include "model/RestartInstanceResult.h"
+#include "model/TransferVersionRequest.h"
+#include "model/TransferVersionResult.h"
+#include "model/UpgradeMinorVersionRequest.h"
+#include "model/UpgradeMinorVersionResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		class ALIBABACLOUD_CLICKHOUSE_EXPORT ClickhouseClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AllocateClusterPublicConnectionResult> AllocateClusterPublicConnectionOutcome;
+			typedef std::future<AllocateClusterPublicConnectionOutcome> AllocateClusterPublicConnectionOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::AllocateClusterPublicConnectionRequest&, const AllocateClusterPublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateClusterPublicConnectionAsyncHandler;
+			typedef Outcome<Error, Model::CheckClickhouseToRDSResult> CheckClickhouseToRDSOutcome;
+			typedef std::future<CheckClickhouseToRDSOutcome> CheckClickhouseToRDSOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CheckClickhouseToRDSRequest&, const CheckClickhouseToRDSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckClickhouseToRDSAsyncHandler;
+			typedef Outcome<Error, Model::CheckModifyConfigNeedRestartResult> CheckModifyConfigNeedRestartOutcome;
+			typedef std::future<CheckModifyConfigNeedRestartOutcome> CheckModifyConfigNeedRestartOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CheckModifyConfigNeedRestartRequest&, const CheckModifyConfigNeedRestartOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckModifyConfigNeedRestartAsyncHandler;
+			typedef Outcome<Error, Model::CheckMonitorAlertResult> CheckMonitorAlertOutcome;
+			typedef std::future<CheckMonitorAlertOutcome> CheckMonitorAlertOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CheckMonitorAlertRequest&, const CheckMonitorAlertOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckMonitorAlertAsyncHandler;
+			typedef Outcome<Error, Model::CheckScaleOutBalancedResult> CheckScaleOutBalancedOutcome;
+			typedef std::future<CheckScaleOutBalancedOutcome> CheckScaleOutBalancedOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CheckScaleOutBalancedRequest&, const CheckScaleOutBalancedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckScaleOutBalancedAsyncHandler;
+			typedef Outcome<Error, Model::CheckServiceLinkedRoleResult> CheckServiceLinkedRoleOutcome;
+			typedef std::future<CheckServiceLinkedRoleOutcome> CheckServiceLinkedRoleOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CheckServiceLinkedRoleRequest&, const CheckServiceLinkedRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckServiceLinkedRoleAsyncHandler;
+			typedef Outcome<Error, Model::CreateAccountResult> CreateAccountOutcome;
+			typedef std::future<CreateAccountOutcome> CreateAccountOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreateAccountRequest&, const CreateAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAccountAsyncHandler;
+			typedef Outcome<Error, Model::CreateAccountAndAuthorityResult> CreateAccountAndAuthorityOutcome;
+			typedef std::future<CreateAccountAndAuthorityOutcome> CreateAccountAndAuthorityOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreateAccountAndAuthorityRequest&, const CreateAccountAndAuthorityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAccountAndAuthorityAsyncHandler;
+			typedef Outcome<Error, Model::CreateBackupPolicyResult> CreateBackupPolicyOutcome;
+			typedef std::future<CreateBackupPolicyOutcome> CreateBackupPolicyOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreateBackupPolicyRequest&, const CreateBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBackupPolicyAsyncHandler;
+			typedef Outcome<Error, Model::CreateDBInstanceResult> CreateDBInstanceOutcome;
+			typedef std::future<CreateDBInstanceOutcome> CreateDBInstanceOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreateDBInstanceRequest&, const CreateDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBInstanceAsyncHandler;
+			typedef Outcome<Error, Model::CreateMonitorDataReportResult> CreateMonitorDataReportOutcome;
+			typedef std::future<CreateMonitorDataReportOutcome> CreateMonitorDataReportOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreateMonitorDataReportRequest&, const CreateMonitorDataReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMonitorDataReportAsyncHandler;
+			typedef Outcome<Error, Model::CreateOSSStorageResult> CreateOSSStorageOutcome;
+			typedef std::future<CreateOSSStorageOutcome> CreateOSSStorageOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreateOSSStorageRequest&, const CreateOSSStorageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOSSStorageAsyncHandler;
+			typedef Outcome<Error, Model::CreatePortsForClickHouseResult> CreatePortsForClickHouseOutcome;
+			typedef std::future<CreatePortsForClickHouseOutcome> CreatePortsForClickHouseOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreatePortsForClickHouseRequest&, const CreatePortsForClickHouseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePortsForClickHouseAsyncHandler;
+			typedef Outcome<Error, Model::CreateRDSToClickhouseDbResult> CreateRDSToClickhouseDbOutcome;
+			typedef std::future<CreateRDSToClickhouseDbOutcome> CreateRDSToClickhouseDbOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreateRDSToClickhouseDbRequest&, const CreateRDSToClickhouseDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRDSToClickhouseDbAsyncHandler;
+			typedef Outcome<Error, Model::CreateSQLAccountResult> CreateSQLAccountOutcome;
+			typedef std::future<CreateSQLAccountOutcome> CreateSQLAccountOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreateSQLAccountRequest&, const CreateSQLAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSQLAccountAsyncHandler;
+			typedef Outcome<Error, Model::CreateServiceLinkedRoleResult> CreateServiceLinkedRoleOutcome;
+			typedef std::future<CreateServiceLinkedRoleOutcome> CreateServiceLinkedRoleOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::CreateServiceLinkedRoleRequest&, const CreateServiceLinkedRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServiceLinkedRoleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteAccountResult> DeleteAccountOutcome;
+			typedef std::future<DeleteAccountOutcome> DeleteAccountOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DeleteAccountRequest&, const DeleteAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAccountAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDBClusterResult> DeleteDBClusterOutcome;
+			typedef std::future<DeleteDBClusterOutcome> DeleteDBClusterOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DeleteDBClusterRequest&, const DeleteDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDBClusterAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSyndbResult> DeleteSyndbOutcome;
+			typedef std::future<DeleteSyndbOutcome> DeleteSyndbOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DeleteSyndbRequest&, const DeleteSyndbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSyndbAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAccountAuthorityResult> DescribeAccountAuthorityOutcome;
+			typedef std::future<DescribeAccountAuthorityOutcome> DescribeAccountAuthorityOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeAccountAuthorityRequest&, const DescribeAccountAuthorityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountAuthorityAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAccountsResult> DescribeAccountsOutcome;
+			typedef std::future<DescribeAccountsOutcome> DescribeAccountsOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeAccountsRequest&, const DescribeAccountsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAllDataSourceResult> DescribeAllDataSourceOutcome;
+			typedef std::future<DescribeAllDataSourceOutcome> DescribeAllDataSourceOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeAllDataSourceRequest&, const DescribeAllDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAllDataSourceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAllDataSourcesResult> DescribeAllDataSourcesOutcome;
+			typedef std::future<DescribeAllDataSourcesOutcome> DescribeAllDataSourcesOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeAllDataSourcesRequest&, const DescribeAllDataSourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAllDataSourcesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeBackupPolicyResult> DescribeBackupPolicyOutcome;
+			typedef std::future<DescribeBackupPolicyOutcome> DescribeBackupPolicyOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeBackupPolicyRequest&, const DescribeBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupPolicyAsyncHandler;
+			typedef Outcome<Error, Model::DescribeBackupsResult> DescribeBackupsOutcome;
+			typedef std::future<DescribeBackupsOutcome> DescribeBackupsOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeBackupsRequest&, const DescribeBackupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeColumnsResult> DescribeColumnsOutcome;
+			typedef std::future<DescribeColumnsOutcome> DescribeColumnsOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeColumnsRequest&, const DescribeColumnsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeColumnsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeConfigHistoryResult> DescribeConfigHistoryOutcome;
+			typedef std::future<DescribeConfigHistoryOutcome> DescribeConfigHistoryOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeConfigHistoryRequest&, const DescribeConfigHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeConfigHistoryAsyncHandler;
+			typedef Outcome<Error, Model::DescribeConfigVersionDifferenceResult> DescribeConfigVersionDifferenceOutcome;
+			typedef std::future<DescribeConfigVersionDifferenceOutcome> DescribeConfigVersionDifferenceOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeConfigVersionDifferenceRequest&, const DescribeConfigVersionDifferenceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeConfigVersionDifferenceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClusterAccessWhiteListResult> DescribeDBClusterAccessWhiteListOutcome;
+			typedef std::future<DescribeDBClusterAccessWhiteListOutcome> DescribeDBClusterAccessWhiteListOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterAccessWhiteListRequest&, const DescribeDBClusterAccessWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterAccessWhiteListAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClusterAttributeResult> DescribeDBClusterAttributeOutcome;
+			typedef std::future<DescribeDBClusterAttributeOutcome> DescribeDBClusterAttributeOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterAttributeRequest&, const DescribeDBClusterAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterAttributeAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClusterConfigResult> DescribeDBClusterConfigOutcome;
+			typedef std::future<DescribeDBClusterConfigOutcome> DescribeDBClusterConfigOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterConfigRequest&, const DescribeDBClusterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClusterConfigInXMLResult> DescribeDBClusterConfigInXMLOutcome;
+			typedef std::future<DescribeDBClusterConfigInXMLOutcome> DescribeDBClusterConfigInXMLOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterConfigInXMLRequest&, const DescribeDBClusterConfigInXMLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterConfigInXMLAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClusterNetInfoItemsResult> DescribeDBClusterNetInfoItemsOutcome;
+			typedef std::future<DescribeDBClusterNetInfoItemsOutcome> DescribeDBClusterNetInfoItemsOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterNetInfoItemsRequest&, const DescribeDBClusterNetInfoItemsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterNetInfoItemsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClusterPerformanceResult> DescribeDBClusterPerformanceOutcome;
+			typedef std::future<DescribeDBClusterPerformanceOutcome> DescribeDBClusterPerformanceOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClusterPerformanceRequest&, const DescribeDBClusterPerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterPerformanceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClustersResult> DescribeDBClustersOutcome;
+			typedef std::future<DescribeDBClustersOutcome> DescribeDBClustersOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBClustersRequest&, const DescribeDBClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClustersAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBConfigResult> DescribeDBConfigOutcome;
+			typedef std::future<DescribeDBConfigOutcome> DescribeDBConfigOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeDBConfigRequest&, const DescribeDBConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeOSSStorageResult> DescribeOSSStorageOutcome;
+			typedef std::future<DescribeOSSStorageOutcome> DescribeOSSStorageOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeOSSStorageRequest&, const DescribeOSSStorageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOSSStorageAsyncHandler;
+			typedef Outcome<Error, Model::DescribeProcessListResult> DescribeProcessListOutcome;
+			typedef std::future<DescribeProcessListOutcome> DescribeProcessListOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeProcessListRequest&, const DescribeProcessListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeProcessListAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSchemasResult> DescribeSchemasOutcome;
+			typedef std::future<DescribeSchemasOutcome> DescribeSchemasOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeSchemasRequest&, const DescribeSchemasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSchemasAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSlowLogRecordsResult> DescribeSlowLogRecordsOutcome;
+			typedef std::future<DescribeSlowLogRecordsOutcome> DescribeSlowLogRecordsOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeSlowLogRecordsRequest&, const DescribeSlowLogRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlowLogRecordsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSynDbTablesResult> DescribeSynDbTablesOutcome;
+			typedef std::future<DescribeSynDbTablesOutcome> DescribeSynDbTablesOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeSynDbTablesRequest&, const DescribeSynDbTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSynDbTablesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSynDbsResult> DescribeSynDbsOutcome;
+			typedef std::future<DescribeSynDbsOutcome> DescribeSynDbsOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeSynDbsRequest&, const DescribeSynDbsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSynDbsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeTablesResult> DescribeTablesOutcome;
+			typedef std::future<DescribeTablesOutcome> DescribeTablesOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeTablesRequest&, const DescribeTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTablesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeTransferHistoryResult> DescribeTransferHistoryOutcome;
+			typedef std::future<DescribeTransferHistoryOutcome> DescribeTransferHistoryOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::DescribeTransferHistoryRequest&, const DescribeTransferHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTransferHistoryAsyncHandler;
+			typedef Outcome<Error, Model::KillProcessResult> KillProcessOutcome;
+			typedef std::future<KillProcessOutcome> KillProcessOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::KillProcessRequest&, const KillProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> KillProcessAsyncHandler;
+			typedef Outcome<Error, Model::ModifyAccountAuthorityResult> ModifyAccountAuthorityOutcome;
+			typedef std::future<ModifyAccountAuthorityOutcome> ModifyAccountAuthorityOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyAccountAuthorityRequest&, const ModifyAccountAuthorityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountAuthorityAsyncHandler;
+			typedef Outcome<Error, Model::ModifyAccountDescriptionResult> ModifyAccountDescriptionOutcome;
+			typedef std::future<ModifyAccountDescriptionOutcome> ModifyAccountDescriptionOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyAccountDescriptionRequest&, const ModifyAccountDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountDescriptionAsyncHandler;
+			typedef Outcome<Error, Model::ModifyBackupPolicyResult> ModifyBackupPolicyOutcome;
+			typedef std::future<ModifyBackupPolicyOutcome> ModifyBackupPolicyOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyBackupPolicyRequest&, const ModifyBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupPolicyAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBClusterResult> ModifyDBClusterOutcome;
+			typedef std::future<ModifyDBClusterOutcome> ModifyDBClusterOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterRequest&, const ModifyDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBClusterAccessWhiteListResult> ModifyDBClusterAccessWhiteListOutcome;
+			typedef std::future<ModifyDBClusterAccessWhiteListOutcome> ModifyDBClusterAccessWhiteListOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterAccessWhiteListRequest&, const ModifyDBClusterAccessWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterAccessWhiteListAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBClusterConfigResult> ModifyDBClusterConfigOutcome;
+			typedef std::future<ModifyDBClusterConfigOutcome> ModifyDBClusterConfigOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterConfigRequest&, const ModifyDBClusterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterConfigAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBClusterConfigInXMLResult> ModifyDBClusterConfigInXMLOutcome;
+			typedef std::future<ModifyDBClusterConfigInXMLOutcome> ModifyDBClusterConfigInXMLOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterConfigInXMLRequest&, const ModifyDBClusterConfigInXMLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterConfigInXMLAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBClusterDescriptionResult> ModifyDBClusterDescriptionOutcome;
+			typedef std::future<ModifyDBClusterDescriptionOutcome> ModifyDBClusterDescriptionOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterDescriptionRequest&, const ModifyDBClusterDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterDescriptionAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBClusterMaintainTimeResult> ModifyDBClusterMaintainTimeOutcome;
+			typedef std::future<ModifyDBClusterMaintainTimeOutcome> ModifyDBClusterMaintainTimeOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBClusterMaintainTimeRequest&, const ModifyDBClusterMaintainTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterMaintainTimeAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBConfigResult> ModifyDBConfigOutcome;
+			typedef std::future<ModifyDBConfigOutcome> ModifyDBConfigOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyDBConfigRequest&, const ModifyDBConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBConfigAsyncHandler;
+			typedef Outcome<Error, Model::ModifyMinorVersionGreadeTypeResult> ModifyMinorVersionGreadeTypeOutcome;
+			typedef std::future<ModifyMinorVersionGreadeTypeOutcome> ModifyMinorVersionGreadeTypeOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyMinorVersionGreadeTypeRequest&, const ModifyMinorVersionGreadeTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyMinorVersionGreadeTypeAsyncHandler;
+			typedef Outcome<Error, Model::ModifyRDSToClickhouseDbResult> ModifyRDSToClickhouseDbOutcome;
+			typedef std::future<ModifyRDSToClickhouseDbOutcome> ModifyRDSToClickhouseDbOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ModifyRDSToClickhouseDbRequest&, const ModifyRDSToClickhouseDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyRDSToClickhouseDbAsyncHandler;
+			typedef Outcome<Error, Model::ReleaseClusterPublicConnectionResult> ReleaseClusterPublicConnectionOutcome;
+			typedef std::future<ReleaseClusterPublicConnectionOutcome> ReleaseClusterPublicConnectionOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ReleaseClusterPublicConnectionRequest&, const ReleaseClusterPublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseClusterPublicConnectionAsyncHandler;
+			typedef Outcome<Error, Model::ResetAccountPasswordResult> ResetAccountPasswordOutcome;
+			typedef std::future<ResetAccountPasswordOutcome> ResetAccountPasswordOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::ResetAccountPasswordRequest&, const ResetAccountPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetAccountPasswordAsyncHandler;
+			typedef Outcome<Error, Model::RestartInstanceResult> RestartInstanceOutcome;
+			typedef std::future<RestartInstanceOutcome> RestartInstanceOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::RestartInstanceRequest&, const RestartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartInstanceAsyncHandler;
+			typedef Outcome<Error, Model::TransferVersionResult> TransferVersionOutcome;
+			typedef std::future<TransferVersionOutcome> TransferVersionOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::TransferVersionRequest&, const TransferVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TransferVersionAsyncHandler;
+			typedef Outcome<Error, Model::UpgradeMinorVersionResult> UpgradeMinorVersionOutcome;
+			typedef std::future<UpgradeMinorVersionOutcome> UpgradeMinorVersionOutcomeCallable;
+			typedef std::function<void(const ClickhouseClient*, const Model::UpgradeMinorVersionRequest&, const UpgradeMinorVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeMinorVersionAsyncHandler;
+
+			ClickhouseClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ClickhouseClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ClickhouseClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ClickhouseClient();
+			AllocateClusterPublicConnectionOutcome allocateClusterPublicConnection(const Model::AllocateClusterPublicConnectionRequest &request)const;
+			void allocateClusterPublicConnectionAsync(const Model::AllocateClusterPublicConnectionRequest& request, const AllocateClusterPublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AllocateClusterPublicConnectionOutcomeCallable allocateClusterPublicConnectionCallable(const Model::AllocateClusterPublicConnectionRequest& request) const;
+			CheckClickhouseToRDSOutcome checkClickhouseToRDS(const Model::CheckClickhouseToRDSRequest &request)const;
+			void checkClickhouseToRDSAsync(const Model::CheckClickhouseToRDSRequest& request, const CheckClickhouseToRDSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckClickhouseToRDSOutcomeCallable checkClickhouseToRDSCallable(const Model::CheckClickhouseToRDSRequest& request) const;
+			CheckModifyConfigNeedRestartOutcome checkModifyConfigNeedRestart(const Model::CheckModifyConfigNeedRestartRequest &request)const;
+			void checkModifyConfigNeedRestartAsync(const Model::CheckModifyConfigNeedRestartRequest& request, const CheckModifyConfigNeedRestartAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckModifyConfigNeedRestartOutcomeCallable checkModifyConfigNeedRestartCallable(const Model::CheckModifyConfigNeedRestartRequest& request) const;
+			CheckMonitorAlertOutcome checkMonitorAlert(const Model::CheckMonitorAlertRequest &request)const;
+			void checkMonitorAlertAsync(const Model::CheckMonitorAlertRequest& request, const CheckMonitorAlertAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckMonitorAlertOutcomeCallable checkMonitorAlertCallable(const Model::CheckMonitorAlertRequest& request) const;
+			CheckScaleOutBalancedOutcome checkScaleOutBalanced(const Model::CheckScaleOutBalancedRequest &request)const;
+			void checkScaleOutBalancedAsync(const Model::CheckScaleOutBalancedRequest& request, const CheckScaleOutBalancedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckScaleOutBalancedOutcomeCallable checkScaleOutBalancedCallable(const Model::CheckScaleOutBalancedRequest& request) const;
+			CheckServiceLinkedRoleOutcome checkServiceLinkedRole(const Model::CheckServiceLinkedRoleRequest &request)const;
+			void checkServiceLinkedRoleAsync(const Model::CheckServiceLinkedRoleRequest& request, const CheckServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckServiceLinkedRoleOutcomeCallable checkServiceLinkedRoleCallable(const Model::CheckServiceLinkedRoleRequest& request) const;
+			CreateAccountOutcome createAccount(const Model::CreateAccountRequest &request)const;
+			void createAccountAsync(const Model::CreateAccountRequest& request, const CreateAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAccountOutcomeCallable createAccountCallable(const Model::CreateAccountRequest& request) const;
+			CreateAccountAndAuthorityOutcome createAccountAndAuthority(const Model::CreateAccountAndAuthorityRequest &request)const;
+			void createAccountAndAuthorityAsync(const Model::CreateAccountAndAuthorityRequest& request, const CreateAccountAndAuthorityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAccountAndAuthorityOutcomeCallable createAccountAndAuthorityCallable(const Model::CreateAccountAndAuthorityRequest& request) const;
+			CreateBackupPolicyOutcome createBackupPolicy(const Model::CreateBackupPolicyRequest &request)const;
+			void createBackupPolicyAsync(const Model::CreateBackupPolicyRequest& request, const CreateBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateBackupPolicyOutcomeCallable createBackupPolicyCallable(const Model::CreateBackupPolicyRequest& request) const;
+			CreateDBInstanceOutcome createDBInstance(const Model::CreateDBInstanceRequest &request)const;
+			void createDBInstanceAsync(const Model::CreateDBInstanceRequest& request, const CreateDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDBInstanceOutcomeCallable createDBInstanceCallable(const Model::CreateDBInstanceRequest& request) const;
+			CreateMonitorDataReportOutcome createMonitorDataReport(const Model::CreateMonitorDataReportRequest &request)const;
+			void createMonitorDataReportAsync(const Model::CreateMonitorDataReportRequest& request, const CreateMonitorDataReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateMonitorDataReportOutcomeCallable createMonitorDataReportCallable(const Model::CreateMonitorDataReportRequest& request) const;
+			CreateOSSStorageOutcome createOSSStorage(const Model::CreateOSSStorageRequest &request)const;
+			void createOSSStorageAsync(const Model::CreateOSSStorageRequest& request, const CreateOSSStorageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateOSSStorageOutcomeCallable createOSSStorageCallable(const Model::CreateOSSStorageRequest& request) const;
+			CreatePortsForClickHouseOutcome createPortsForClickHouse(const Model::CreatePortsForClickHouseRequest &request)const;
+			void createPortsForClickHouseAsync(const Model::CreatePortsForClickHouseRequest& request, const CreatePortsForClickHouseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreatePortsForClickHouseOutcomeCallable createPortsForClickHouseCallable(const Model::CreatePortsForClickHouseRequest& request) const;
+			CreateRDSToClickhouseDbOutcome createRDSToClickhouseDb(const Model::CreateRDSToClickhouseDbRequest &request)const;
+			void createRDSToClickhouseDbAsync(const Model::CreateRDSToClickhouseDbRequest& request, const CreateRDSToClickhouseDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateRDSToClickhouseDbOutcomeCallable createRDSToClickhouseDbCallable(const Model::CreateRDSToClickhouseDbRequest& request) const;
+			CreateSQLAccountOutcome createSQLAccount(const Model::CreateSQLAccountRequest &request)const;
+			void createSQLAccountAsync(const Model::CreateSQLAccountRequest& request, const CreateSQLAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateSQLAccountOutcomeCallable createSQLAccountCallable(const Model::CreateSQLAccountRequest& request) const;
+			CreateServiceLinkedRoleOutcome createServiceLinkedRole(const Model::CreateServiceLinkedRoleRequest &request)const;
+			void createServiceLinkedRoleAsync(const Model::CreateServiceLinkedRoleRequest& request, const CreateServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateServiceLinkedRoleOutcomeCallable createServiceLinkedRoleCallable(const Model::CreateServiceLinkedRoleRequest& request) const;
+			DeleteAccountOutcome deleteAccount(const Model::DeleteAccountRequest &request)const;
+			void deleteAccountAsync(const Model::DeleteAccountRequest& request, const DeleteAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteAccountOutcomeCallable deleteAccountCallable(const Model::DeleteAccountRequest& request) const;
+			DeleteDBClusterOutcome deleteDBCluster(const Model::DeleteDBClusterRequest &request)const;
+			void deleteDBClusterAsync(const Model::DeleteDBClusterRequest& request, const DeleteDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteDBClusterOutcomeCallable deleteDBClusterCallable(const Model::DeleteDBClusterRequest& request) const;
+			DeleteSyndbOutcome deleteSyndb(const Model::DeleteSyndbRequest &request)const;
+			void deleteSyndbAsync(const Model::DeleteSyndbRequest& request, const DeleteSyndbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSyndbOutcomeCallable deleteSyndbCallable(const Model::DeleteSyndbRequest& request) const;
+			DescribeAccountAuthorityOutcome describeAccountAuthority(const Model::DescribeAccountAuthorityRequest &request)const;
+			void describeAccountAuthorityAsync(const Model::DescribeAccountAuthorityRequest& request, const DescribeAccountAuthorityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAccountAuthorityOutcomeCallable describeAccountAuthorityCallable(const Model::DescribeAccountAuthorityRequest& request) const;
+			DescribeAccountsOutcome describeAccounts(const Model::DescribeAccountsRequest &request)const;
+			void describeAccountsAsync(const Model::DescribeAccountsRequest& request, const DescribeAccountsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAccountsOutcomeCallable describeAccountsCallable(const Model::DescribeAccountsRequest& request) const;
+			DescribeAllDataSourceOutcome describeAllDataSource(const Model::DescribeAllDataSourceRequest &request)const;
+			void describeAllDataSourceAsync(const Model::DescribeAllDataSourceRequest& request, const DescribeAllDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAllDataSourceOutcomeCallable describeAllDataSourceCallable(const Model::DescribeAllDataSourceRequest& request) const;
+			DescribeAllDataSourcesOutcome describeAllDataSources(const Model::DescribeAllDataSourcesRequest &request)const;
+			void describeAllDataSourcesAsync(const Model::DescribeAllDataSourcesRequest& request, const DescribeAllDataSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAllDataSourcesOutcomeCallable describeAllDataSourcesCallable(const Model::DescribeAllDataSourcesRequest& request) const;
+			DescribeBackupPolicyOutcome describeBackupPolicy(const Model::DescribeBackupPolicyRequest &request)const;
+			void describeBackupPolicyAsync(const Model::DescribeBackupPolicyRequest& request, const DescribeBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeBackupPolicyOutcomeCallable describeBackupPolicyCallable(const Model::DescribeBackupPolicyRequest& request) const;
+			DescribeBackupsOutcome describeBackups(const Model::DescribeBackupsRequest &request)const;
+			void describeBackupsAsync(const Model::DescribeBackupsRequest& request, const DescribeBackupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeBackupsOutcomeCallable describeBackupsCallable(const Model::DescribeBackupsRequest& request) const;
+			DescribeColumnsOutcome describeColumns(const Model::DescribeColumnsRequest &request)const;
+			void describeColumnsAsync(const Model::DescribeColumnsRequest& request, const DescribeColumnsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeColumnsOutcomeCallable describeColumnsCallable(const Model::DescribeColumnsRequest& request) const;
+			DescribeConfigHistoryOutcome describeConfigHistory(const Model::DescribeConfigHistoryRequest &request)const;
+			void describeConfigHistoryAsync(const Model::DescribeConfigHistoryRequest& request, const DescribeConfigHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeConfigHistoryOutcomeCallable describeConfigHistoryCallable(const Model::DescribeConfigHistoryRequest& request) const;
+			DescribeConfigVersionDifferenceOutcome describeConfigVersionDifference(const Model::DescribeConfigVersionDifferenceRequest &request)const;
+			void describeConfigVersionDifferenceAsync(const Model::DescribeConfigVersionDifferenceRequest& request, const DescribeConfigVersionDifferenceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeConfigVersionDifferenceOutcomeCallable describeConfigVersionDifferenceCallable(const Model::DescribeConfigVersionDifferenceRequest& request) const;
+			DescribeDBClusterAccessWhiteListOutcome describeDBClusterAccessWhiteList(const Model::DescribeDBClusterAccessWhiteListRequest &request)const;
+			void describeDBClusterAccessWhiteListAsync(const Model::DescribeDBClusterAccessWhiteListRequest& request, const DescribeDBClusterAccessWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClusterAccessWhiteListOutcomeCallable describeDBClusterAccessWhiteListCallable(const Model::DescribeDBClusterAccessWhiteListRequest& request) const;
+			DescribeDBClusterAttributeOutcome describeDBClusterAttribute(const Model::DescribeDBClusterAttributeRequest &request)const;
+			void describeDBClusterAttributeAsync(const Model::DescribeDBClusterAttributeRequest& request, const DescribeDBClusterAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClusterAttributeOutcomeCallable describeDBClusterAttributeCallable(const Model::DescribeDBClusterAttributeRequest& request) const;
+			DescribeDBClusterConfigOutcome describeDBClusterConfig(const Model::DescribeDBClusterConfigRequest &request)const;
+			void describeDBClusterConfigAsync(const Model::DescribeDBClusterConfigRequest& request, const DescribeDBClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClusterConfigOutcomeCallable describeDBClusterConfigCallable(const Model::DescribeDBClusterConfigRequest& request) const;
+			DescribeDBClusterConfigInXMLOutcome describeDBClusterConfigInXML(const Model::DescribeDBClusterConfigInXMLRequest &request)const;
+			void describeDBClusterConfigInXMLAsync(const Model::DescribeDBClusterConfigInXMLRequest& request, const DescribeDBClusterConfigInXMLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClusterConfigInXMLOutcomeCallable describeDBClusterConfigInXMLCallable(const Model::DescribeDBClusterConfigInXMLRequest& request) const;
+			DescribeDBClusterNetInfoItemsOutcome describeDBClusterNetInfoItems(const Model::DescribeDBClusterNetInfoItemsRequest &request)const;
+			void describeDBClusterNetInfoItemsAsync(const Model::DescribeDBClusterNetInfoItemsRequest& request, const DescribeDBClusterNetInfoItemsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClusterNetInfoItemsOutcomeCallable describeDBClusterNetInfoItemsCallable(const Model::DescribeDBClusterNetInfoItemsRequest& request) const;
+			DescribeDBClusterPerformanceOutcome describeDBClusterPerformance(const Model::DescribeDBClusterPerformanceRequest &request)const;
+			void describeDBClusterPerformanceAsync(const Model::DescribeDBClusterPerformanceRequest& request, const DescribeDBClusterPerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClusterPerformanceOutcomeCallable describeDBClusterPerformanceCallable(const Model::DescribeDBClusterPerformanceRequest& request) const;
+			DescribeDBClustersOutcome describeDBClusters(const Model::DescribeDBClustersRequest &request)const;
+			void describeDBClustersAsync(const Model::DescribeDBClustersRequest& request, const DescribeDBClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClustersOutcomeCallable describeDBClustersCallable(const Model::DescribeDBClustersRequest& request) const;
+			DescribeDBConfigOutcome describeDBConfig(const Model::DescribeDBConfigRequest &request)const;
+			void describeDBConfigAsync(const Model::DescribeDBConfigRequest& request, const DescribeDBConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBConfigOutcomeCallable describeDBConfigCallable(const Model::DescribeDBConfigRequest& request) const;
+			DescribeOSSStorageOutcome describeOSSStorage(const Model::DescribeOSSStorageRequest &request)const;
+			void describeOSSStorageAsync(const Model::DescribeOSSStorageRequest& request, const DescribeOSSStorageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeOSSStorageOutcomeCallable describeOSSStorageCallable(const Model::DescribeOSSStorageRequest& request) const;
+			DescribeProcessListOutcome describeProcessList(const Model::DescribeProcessListRequest &request)const;
+			void describeProcessListAsync(const Model::DescribeProcessListRequest& request, const DescribeProcessListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeProcessListOutcomeCallable describeProcessListCallable(const Model::DescribeProcessListRequest& request) const;
+			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
+			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			DescribeSchemasOutcome describeSchemas(const Model::DescribeSchemasRequest &request)const;
+			void describeSchemasAsync(const Model::DescribeSchemasRequest& request, const DescribeSchemasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSchemasOutcomeCallable describeSchemasCallable(const Model::DescribeSchemasRequest& request) const;
+			DescribeSlowLogRecordsOutcome describeSlowLogRecords(const Model::DescribeSlowLogRecordsRequest &request)const;
+			void describeSlowLogRecordsAsync(const Model::DescribeSlowLogRecordsRequest& request, const DescribeSlowLogRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSlowLogRecordsOutcomeCallable describeSlowLogRecordsCallable(const Model::DescribeSlowLogRecordsRequest& request) const;
+			DescribeSynDbTablesOutcome describeSynDbTables(const Model::DescribeSynDbTablesRequest &request)const;
+			void describeSynDbTablesAsync(const Model::DescribeSynDbTablesRequest& request, const DescribeSynDbTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSynDbTablesOutcomeCallable describeSynDbTablesCallable(const Model::DescribeSynDbTablesRequest& request) const;
+			DescribeSynDbsOutcome describeSynDbs(const Model::DescribeSynDbsRequest &request)const;
+			void describeSynDbsAsync(const Model::DescribeSynDbsRequest& request, const DescribeSynDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSynDbsOutcomeCallable describeSynDbsCallable(const Model::DescribeSynDbsRequest& request) const;
+			DescribeTablesOutcome describeTables(const Model::DescribeTablesRequest &request)const;
+			void describeTablesAsync(const Model::DescribeTablesRequest& request, const DescribeTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeTablesOutcomeCallable describeTablesCallable(const Model::DescribeTablesRequest& request) const;
+			DescribeTransferHistoryOutcome describeTransferHistory(const Model::DescribeTransferHistoryRequest &request)const;
+			void describeTransferHistoryAsync(const Model::DescribeTransferHistoryRequest& request, const DescribeTransferHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeTransferHistoryOutcomeCallable describeTransferHistoryCallable(const Model::DescribeTransferHistoryRequest& request) const;
+			KillProcessOutcome killProcess(const Model::KillProcessRequest &request)const;
+			void killProcessAsync(const Model::KillProcessRequest& request, const KillProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			KillProcessOutcomeCallable killProcessCallable(const Model::KillProcessRequest& request) const;
+			ModifyAccountAuthorityOutcome modifyAccountAuthority(const Model::ModifyAccountAuthorityRequest &request)const;
+			void modifyAccountAuthorityAsync(const Model::ModifyAccountAuthorityRequest& request, const ModifyAccountAuthorityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyAccountAuthorityOutcomeCallable modifyAccountAuthorityCallable(const Model::ModifyAccountAuthorityRequest& request) const;
+			ModifyAccountDescriptionOutcome modifyAccountDescription(const Model::ModifyAccountDescriptionRequest &request)const;
+			void modifyAccountDescriptionAsync(const Model::ModifyAccountDescriptionRequest& request, const ModifyAccountDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyAccountDescriptionOutcomeCallable modifyAccountDescriptionCallable(const Model::ModifyAccountDescriptionRequest& request) const;
+			ModifyBackupPolicyOutcome modifyBackupPolicy(const Model::ModifyBackupPolicyRequest &request)const;
+			void modifyBackupPolicyAsync(const Model::ModifyBackupPolicyRequest& request, const ModifyBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyBackupPolicyOutcomeCallable modifyBackupPolicyCallable(const Model::ModifyBackupPolicyRequest& request) const;
+			ModifyDBClusterOutcome modifyDBCluster(const Model::ModifyDBClusterRequest &request)const;
+			void modifyDBClusterAsync(const Model::ModifyDBClusterRequest& request, const ModifyDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDBClusterOutcomeCallable modifyDBClusterCallable(const Model::ModifyDBClusterRequest& request) const;
+			ModifyDBClusterAccessWhiteListOutcome modifyDBClusterAccessWhiteList(const Model::ModifyDBClusterAccessWhiteListRequest &request)const;
+			void modifyDBClusterAccessWhiteListAsync(const Model::ModifyDBClusterAccessWhiteListRequest& request, const ModifyDBClusterAccessWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDBClusterAccessWhiteListOutcomeCallable modifyDBClusterAccessWhiteListCallable(const Model::ModifyDBClusterAccessWhiteListRequest& request) const;
+			ModifyDBClusterConfigOutcome modifyDBClusterConfig(const Model::ModifyDBClusterConfigRequest &request)const;
+			void modifyDBClusterConfigAsync(const Model::ModifyDBClusterConfigRequest& request, const ModifyDBClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDBClusterConfigOutcomeCallable modifyDBClusterConfigCallable(const Model::ModifyDBClusterConfigRequest& request) const;
+			ModifyDBClusterConfigInXMLOutcome modifyDBClusterConfigInXML(const Model::ModifyDBClusterConfigInXMLRequest &request)const;
+			void modifyDBClusterConfigInXMLAsync(const Model::ModifyDBClusterConfigInXMLRequest& request, const ModifyDBClusterConfigInXMLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDBClusterConfigInXMLOutcomeCallable modifyDBClusterConfigInXMLCallable(const Model::ModifyDBClusterConfigInXMLRequest& request) const;
+			ModifyDBClusterDescriptionOutcome modifyDBClusterDescription(const Model::ModifyDBClusterDescriptionRequest &request)const;
+			void modifyDBClusterDescriptionAsync(const Model::ModifyDBClusterDescriptionRequest& request, const ModifyDBClusterDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDBClusterDescriptionOutcomeCallable modifyDBClusterDescriptionCallable(const Model::ModifyDBClusterDescriptionRequest& request) const;
+			ModifyDBClusterMaintainTimeOutcome modifyDBClusterMaintainTime(const Model::ModifyDBClusterMaintainTimeRequest &request)const;
+			void modifyDBClusterMaintainTimeAsync(const Model::ModifyDBClusterMaintainTimeRequest& request, const ModifyDBClusterMaintainTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDBClusterMaintainTimeOutcomeCallable modifyDBClusterMaintainTimeCallable(const Model::ModifyDBClusterMaintainTimeRequest& request) const;
+			ModifyDBConfigOutcome modifyDBConfig(const Model::ModifyDBConfigRequest &request)const;
+			void modifyDBConfigAsync(const Model::ModifyDBConfigRequest& request, const ModifyDBConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDBConfigOutcomeCallable modifyDBConfigCallable(const Model::ModifyDBConfigRequest& request) const;
+			ModifyMinorVersionGreadeTypeOutcome modifyMinorVersionGreadeType(const Model::ModifyMinorVersionGreadeTypeRequest &request)const;
+			void modifyMinorVersionGreadeTypeAsync(const Model::ModifyMinorVersionGreadeTypeRequest& request, const ModifyMinorVersionGreadeTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyMinorVersionGreadeTypeOutcomeCallable modifyMinorVersionGreadeTypeCallable(const Model::ModifyMinorVersionGreadeTypeRequest& request) const;
+			ModifyRDSToClickhouseDbOutcome modifyRDSToClickhouseDb(const Model::ModifyRDSToClickhouseDbRequest &request)const;
+			void modifyRDSToClickhouseDbAsync(const Model::ModifyRDSToClickhouseDbRequest& request, const ModifyRDSToClickhouseDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyRDSToClickhouseDbOutcomeCallable modifyRDSToClickhouseDbCallable(const Model::ModifyRDSToClickhouseDbRequest& request) const;
+			ReleaseClusterPublicConnectionOutcome releaseClusterPublicConnection(const Model::ReleaseClusterPublicConnectionRequest &request)const;
+			void releaseClusterPublicConnectionAsync(const Model::ReleaseClusterPublicConnectionRequest& request, const ReleaseClusterPublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReleaseClusterPublicConnectionOutcomeCallable releaseClusterPublicConnectionCallable(const Model::ReleaseClusterPublicConnectionRequest& request) const;
+			ResetAccountPasswordOutcome resetAccountPassword(const Model::ResetAccountPasswordRequest &request)const;
+			void resetAccountPasswordAsync(const Model::ResetAccountPasswordRequest& request, const ResetAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResetAccountPasswordOutcomeCallable resetAccountPasswordCallable(const Model::ResetAccountPasswordRequest& 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;
+			TransferVersionOutcome transferVersion(const Model::TransferVersionRequest &request)const;
+			void transferVersionAsync(const Model::TransferVersionRequest& request, const TransferVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TransferVersionOutcomeCallable transferVersionCallable(const Model::TransferVersionRequest& request) const;
+			UpgradeMinorVersionOutcome upgradeMinorVersion(const Model::UpgradeMinorVersionRequest &request)const;
+			void upgradeMinorVersionAsync(const Model::UpgradeMinorVersionRequest& request, const UpgradeMinorVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpgradeMinorVersionOutcomeCallable upgradeMinorVersionCallable(const Model::UpgradeMinorVersionRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_CLICKHOUSE_CLICKHOUSECLIENT_H_

clickhouse/include/alibabacloud/clickhouse/ClickhouseExport.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_CLICKHOUSE_CLICKHOUSEEXPORT_H_
+#define ALIBABACLOUD_CLICKHOUSE_CLICKHOUSEEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_CLICKHOUSE_LIBRARY)
+#		define ALIBABACLOUD_CLICKHOUSE_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_CLICKHOUSE_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_CLICKHOUSE_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_CLICKHOUSE_CLICKHOUSEEXPORT_H_

clickhouse/include/alibabacloud/clickhouse/model/AllocateClusterPublicConnectionRequest.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_CLICKHOUSE_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT AllocateClusterPublicConnectionRequest : public RpcServiceRequest {
+public:
+	AllocateClusterPublicConnectionRequest();
+	~AllocateClusterPublicConnectionRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getConnectionStringPrefix() const;
+	void setConnectionStringPrefix(const std::string &connectionStringPrefix);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string connectionStringPrefix_;
+	std::string accessKeyId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/AllocateClusterPublicConnectionResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/CheckClickhouseToRDSRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckClickhouseToRDSRequest : public RpcServiceRequest {
+public:
+	CheckClickhouseToRDSRequest();
+	~CheckClickhouseToRDSRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRdsVpcId() const;
+	void setRdsVpcId(const std::string &rdsVpcId);
+	std::string getCkPassword() const;
+	void setCkPassword(const std::string &ckPassword);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRdsPassword() const;
+	void setRdsPassword(const std::string &rdsPassword);
+	std::string getCkUserName() const;
+	void setCkUserName(const std::string &ckUserName);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDbClusterId() const;
+	void setDbClusterId(const std::string &dbClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getRdsId() const;
+	void setRdsId(const std::string &rdsId);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	long getClickhousePort() const;
+	void setClickhousePort(long clickhousePort);
+	long getRdsPort() const;
+	void setRdsPort(long rdsPort);
+	std::string getRdsVpcUrl() const;
+	void setRdsVpcUrl(const std::string &rdsVpcUrl);
+	std::string getRdsUserName() const;
+	void setRdsUserName(const std::string &rdsUserName);
+
+private:
+	long resourceOwnerId_;
+	std::string rdsVpcId_;
+	std::string ckPassword_;
+	std::string accessKeyId_;
+	std::string rdsPassword_;
+	std::string ckUserName_;
+	std::string resourceOwnerAccount_;
+	std::string dbClusterId_;
+	std::string ownerAccount_;
+	std::string rdsId_;
+	long ownerId_;
+	long clickhousePort_;
+	long rdsPort_;
+	std::string rdsVpcUrl_;
+	std::string rdsUserName_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CheckClickhouseToRDSResult.h

@@ -0,0 +1,53 @@
+/*
+ * 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_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckClickhouseToRDSResult : public ServiceResult
+			{
+			public:
+
+
+				CheckClickhouseToRDSResult();
+				explicit CheckClickhouseToRDSResult(const std::string &payload);
+				~CheckClickhouseToRDSResult();
+				bool getStatus()const;
+				std::string getErrorCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool status_;
+				std::string errorCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKCLICKHOUSETORDSRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/CheckModifyConfigNeedRestartRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckModifyConfigNeedRestartRequest : public RpcServiceRequest {
+public:
+	CheckModifyConfigNeedRestartRequest();
+	~CheckModifyConfigNeedRestartRequest();
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getConfig() const;
+	void setConfig(const std::string &config);
+
+private:
+	std::string dBClusterId_;
+	std::string config_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CheckModifyConfigNeedRestartResult.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_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckModifyConfigNeedRestartResult : public ServiceResult
+			{
+			public:
+
+
+				CheckModifyConfigNeedRestartResult();
+				explicit CheckModifyConfigNeedRestartResult(const std::string &payload);
+				~CheckModifyConfigNeedRestartResult();
+				bool getNeedRestart()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool needRestart_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMODIFYCONFIGNEEDRESTARTRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/CheckMonitorAlertRequest.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_CLICKHOUSE_MODEL_CHECKMONITORALERTREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckMonitorAlertRequest : public RpcServiceRequest {
+public:
+	CheckMonitorAlertRequest();
+	~CheckMonitorAlertRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CheckMonitorAlertResult.h

@@ -0,0 +1,53 @@
+/*
+ * 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_CLICKHOUSE_MODEL_CHECKMONITORALERTRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckMonitorAlertResult : public ServiceResult
+			{
+			public:
+
+
+				CheckMonitorAlertResult();
+				explicit CheckMonitorAlertResult(const std::string &payload);
+				~CheckMonitorAlertResult();
+				std::string getState()const;
+				std::string get_Parameter()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string state_;
+				std::string _parameter_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKMONITORALERTRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/CheckScaleOutBalancedRequest.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_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckScaleOutBalancedRequest : public RpcServiceRequest {
+public:
+	CheckScaleOutBalancedRequest();
+	~CheckScaleOutBalancedRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	int pageNumber_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	int pageSize_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CheckScaleOutBalancedResult.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckScaleOutBalancedResult : public ServiceResult
+			{
+			public:
+				struct TableDetail
+				{
+					std::string tableName;
+					std::string database;
+					std::string cluster;
+					int detail;
+				};
+
+
+				CheckScaleOutBalancedResult();
+				explicit CheckScaleOutBalancedResult(const std::string &payload);
+				~CheckScaleOutBalancedResult();
+				std::vector<TableDetail> getTableDetails()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::string getCheckCode()const;
+				std::string getTimeDuration()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<TableDetail> tableDetails_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::string checkCode_;
+				std::string timeDuration_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSCALEOUTBALANCEDRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/CheckServiceLinkedRoleRequest.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_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLEREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckServiceLinkedRoleRequest : public RpcServiceRequest {
+public:
+	CheckServiceLinkedRoleRequest();
+	~CheckServiceLinkedRoleRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CheckServiceLinkedRoleResult.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_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLERESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT CheckServiceLinkedRoleResult : public ServiceResult
+			{
+			public:
+
+
+				CheckServiceLinkedRoleResult();
+				explicit CheckServiceLinkedRoleResult(const std::string &payload);
+				~CheckServiceLinkedRoleResult();
+				bool getHasServiceLinkedRole()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool hasServiceLinkedRole_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CHECKSERVICELINKEDROLERESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateAccountAndAuthorityRequest.h

@@ -0,0 +1,87 @@
+/*
+ * 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_CLICKHOUSE_MODEL_CREATEACCOUNTANDAUTHORITYREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTANDAUTHORITYREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateAccountAndAuthorityRequest : public RpcServiceRequest {
+public:
+	CreateAccountAndAuthorityRequest();
+	~CreateAccountAndAuthorityRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getTotalDictionaries() const;
+	void setTotalDictionaries(const std::string &totalDictionaries);
+	std::string getAccountDescription() const;
+	void setAccountDescription(const std::string &accountDescription);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getAccountName() const;
+	void setAccountName(const std::string &accountName);
+	std::string getDmlAuthority() const;
+	void setDmlAuthority(const std::string &dmlAuthority);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getAllowDatabases() const;
+	void setAllowDatabases(const std::string &allowDatabases);
+	std::string getAllowDictionaries() const;
+	void setAllowDictionaries(const std::string &allowDictionaries);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getAccountPassword() const;
+	void setAccountPassword(const std::string &accountPassword);
+	bool getDdlAuthority() const;
+	void setDdlAuthority(bool ddlAuthority);
+	std::string getTotalDatabases() const;
+	void setTotalDatabases(const std::string &totalDatabases);
+
+private:
+	long resourceOwnerId_;
+	std::string totalDictionaries_;
+	std::string accountDescription_;
+	std::string accessKeyId_;
+	std::string accountName_;
+	std::string dmlAuthority_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	std::string allowDatabases_;
+	std::string allowDictionaries_;
+	long ownerId_;
+	std::string accountPassword_;
+	bool ddlAuthority_;
+	std::string totalDatabases_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTANDAUTHORITYREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateAccountAndAuthorityResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/CreateAccountRequest.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_CLICKHOUSE_MODEL_CREATEACCOUNTREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateAccountRequest : public RpcServiceRequest {
+public:
+	CreateAccountRequest();
+	~CreateAccountRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccountDescription() const;
+	void setAccountDescription(const std::string &accountDescription);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getAccountName() const;
+	void setAccountName(const std::string &accountName);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getAccountPassword() const;
+	void setAccountPassword(const std::string &accountPassword);
+
+private:
+	long resourceOwnerId_;
+	std::string accountDescription_;
+	std::string accessKeyId_;
+	std::string accountName_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string accountPassword_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEACCOUNTREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateAccountResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/CreateBackupPolicyRequest.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_CLICKHOUSE_MODEL_CREATEBACKUPPOLICYREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEBACKUPPOLICYREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateBackupPolicyRequest : public RpcServiceRequest {
+public:
+	CreateBackupPolicyRequest();
+	~CreateBackupPolicyRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getPreferredBackupPeriod() const;
+	void setPreferredBackupPeriod(const std::string &preferredBackupPeriod);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getPreferredBackupTime() const;
+	void setPreferredBackupTime(const std::string &preferredBackupTime);
+	std::string getBackupRetentionPeriod() const;
+	void setBackupRetentionPeriod(const std::string &backupRetentionPeriod);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	std::string preferredBackupPeriod_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string preferredBackupTime_;
+	std::string backupRetentionPeriod_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEBACKUPPOLICYREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateBackupPolicyResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/CreateDBInstanceRequest.h

@@ -0,0 +1,132 @@
+/*
+ * 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_CLICKHOUSE_MODEL_CREATEDBINSTANCEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCEREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateDBInstanceRequest : public RpcServiceRequest {
+public:
+	CreateDBInstanceRequest();
+	~CreateDBInstanceRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getDBClusterDescription() const;
+	void setDBClusterDescription(const std::string &dBClusterDescription);
+	std::string getSourceDBClusterId() const;
+	void setSourceDBClusterId(const std::string &sourceDBClusterId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getZondIdBak2() const;
+	void setZondIdBak2(const std::string &zondIdBak2);
+	std::string getDbNodeStorageType() const;
+	void setDbNodeStorageType(const std::string &dbNodeStorageType);
+	std::string getEncryptionType() const;
+	void setEncryptionType(const std::string &encryptionType);
+	std::string getZoneIdBak() const;
+	void setZoneIdBak(const std::string &zoneIdBak);
+	std::string getPeriod() const;
+	void setPeriod(const std::string &period);
+	std::string getBackupSetID() const;
+	void setBackupSetID(const std::string &backupSetID);
+	std::string getEncryptionKey() const;
+	void setEncryptionKey(const std::string &encryptionKey);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getDBNodeGroupCount() const;
+	void setDBNodeGroupCount(const std::string &dBNodeGroupCount);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	bool getAutoRenew() const;
+	void setAutoRenew(bool autoRenew);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBClusterCategory() const;
+	void setDBClusterCategory(const std::string &dBClusterCategory);
+	std::string getDBClusterNetworkType() const;
+	void setDBClusterNetworkType(const std::string &dBClusterNetworkType);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getDBClusterVersion() const;
+	void setDBClusterVersion(const std::string &dBClusterVersion);
+	std::string getDBClusterClass() const;
+	void setDBClusterClass(const std::string &dBClusterClass);
+	std::string getVSwitchBak() const;
+	void setVSwitchBak(const std::string &vSwitchBak);
+	std::string getUsedTime() const;
+	void setUsedTime(const std::string &usedTime);
+	std::string getVSwitchBak2() const;
+	void setVSwitchBak2(const std::string &vSwitchBak2);
+	std::string getDBNodeStorage() const;
+	void setDBNodeStorage(const std::string &dBNodeStorage);
+	std::string getVPCId() const;
+	void setVPCId(const std::string &vPCId);
+	std::string getPayType() const;
+	void setPayType(const std::string &payType);
+
+private:
+	long resourceOwnerId_;
+	std::string dBClusterDescription_;
+	std::string sourceDBClusterId_;
+	std::string resourceGroupId_;
+	std::string zondIdBak2_;
+	std::string dbNodeStorageType_;
+	std::string encryptionType_;
+	std::string zoneIdBak_;
+	std::string period_;
+	std::string backupSetID_;
+	std::string encryptionKey_;
+	long ownerId_;
+	std::string dBNodeGroupCount_;
+	std::string vSwitchId_;
+	bool autoRenew_;
+	std::string zoneId_;
+	std::string clientToken_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	std::string dBClusterCategory_;
+	std::string dBClusterNetworkType_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string dBClusterVersion_;
+	std::string dBClusterClass_;
+	std::string vSwitchBak_;
+	std::string usedTime_;
+	std::string vSwitchBak2_;
+	std::string dBNodeStorage_;
+	std::string vPCId_;
+	std::string payType_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateDBInstanceResult.h

@@ -0,0 +1,53 @@
+/*
+ * 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_CLICKHOUSE_MODEL_CREATEDBINSTANCERESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateDBInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateDBInstanceResult();
+				explicit CreateDBInstanceResult(const std::string &payload);
+				~CreateDBInstanceResult();
+				std::string getDBClusterId()const;
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string dBClusterId_;
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEDBINSTANCERESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateMonitorDataReportRequest.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_CLICKHOUSE_MODEL_CREATEMONITORDATAREPORTREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEMONITORDATAREPORTREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateMonitorDataReportRequest : public RpcServiceRequest {
+public:
+	CreateMonitorDataReportRequest();
+	~CreateMonitorDataReportRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEMONITORDATAREPORTREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateMonitorDataReportResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/CreateOSSStorageRequest.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_CLICKHOUSE_MODEL_CREATEOSSSTORAGEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEOSSSTORAGEREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateOSSStorageRequest : public RpcServiceRequest {
+public:
+	CreateOSSStorageRequest();
+	~CreateOSSStorageRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEOSSSTORAGEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateOSSStorageResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/CreatePortsForClickHouseRequest.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_CLICKHOUSE_MODEL_CREATEPORTSFORCLICKHOUSEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEPORTSFORCLICKHOUSEREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreatePortsForClickHouseRequest : public RpcServiceRequest {
+public:
+	CreatePortsForClickHouseRequest();
+	~CreatePortsForClickHouseRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getPortType() const;
+	void setPortType(const std::string &portType);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string portType_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATEPORTSFORCLICKHOUSEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreatePortsForClickHouseResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/CreateRDSToClickhouseDbRequest.h

@@ -0,0 +1,93 @@
+/*
+ * 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_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateRDSToClickhouseDbRequest : public RpcServiceRequest {
+public:
+	CreateRDSToClickhouseDbRequest();
+	~CreateRDSToClickhouseDbRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getSynDbTables() const;
+	void setSynDbTables(const std::string &synDbTables);
+	std::string getRdsVpcId() const;
+	void setRdsVpcId(const std::string &rdsVpcId);
+	std::string getCkPassword() const;
+	void setCkPassword(const std::string &ckPassword);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRdsPassword() const;
+	void setRdsPassword(const std::string &rdsPassword);
+	std::string getCkUserName() const;
+	void setCkUserName(const std::string &ckUserName);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDbClusterId() const;
+	void setDbClusterId(const std::string &dbClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getRdsId() const;
+	void setRdsId(const std::string &rdsId);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	long getClickhousePort() const;
+	void setClickhousePort(long clickhousePort);
+	long getLimitUpper() const;
+	void setLimitUpper(long limitUpper);
+	long getRdsPort() const;
+	void setRdsPort(long rdsPort);
+	bool getSkipUnsupported() const;
+	void setSkipUnsupported(bool skipUnsupported);
+	std::string getRdsVpcUrl() const;
+	void setRdsVpcUrl(const std::string &rdsVpcUrl);
+	std::string getRdsUserName() const;
+	void setRdsUserName(const std::string &rdsUserName);
+
+private:
+	long resourceOwnerId_;
+	std::string synDbTables_;
+	std::string rdsVpcId_;
+	std::string ckPassword_;
+	std::string accessKeyId_;
+	std::string rdsPassword_;
+	std::string ckUserName_;
+	std::string resourceOwnerAccount_;
+	std::string dbClusterId_;
+	std::string ownerAccount_;
+	std::string rdsId_;
+	long ownerId_;
+	long clickhousePort_;
+	long limitUpper_;
+	long rdsPort_;
+	bool skipUnsupported_;
+	std::string rdsVpcUrl_;
+	std::string rdsUserName_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateRDSToClickhouseDbResult.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_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateRDSToClickhouseDbResult : public ServiceResult
+			{
+			public:
+
+
+				CreateRDSToClickhouseDbResult();
+				explicit CreateRDSToClickhouseDbResult(const std::string &payload);
+				~CreateRDSToClickhouseDbResult();
+				long getStatus()const;
+				std::vector<std::string> getRepeatedDbs()const;
+				std::string getErrorMsg()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long status_;
+				std::vector<std::string> repeatedDbs_;
+				std::string errorMsg_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATERDSTOCLICKHOUSEDBRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateSQLAccountRequest.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_CLICKHOUSE_MODEL_CREATESQLACCOUNTREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESQLACCOUNTREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateSQLAccountRequest : public RpcServiceRequest {
+public:
+	CreateSQLAccountRequest();
+	~CreateSQLAccountRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccountType() const;
+	void setAccountType(const std::string &accountType);
+	std::string getAccountDescription() const;
+	void setAccountDescription(const std::string &accountDescription);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getAccountName() const;
+	void setAccountName(const std::string &accountName);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getAccountPassword() const;
+	void setAccountPassword(const std::string &accountPassword);
+
+private:
+	long resourceOwnerId_;
+	std::string accountType_;
+	std::string accountDescription_;
+	std::string accessKeyId_;
+	std::string accountName_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string accountPassword_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESQLACCOUNTREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateSQLAccountResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/CreateServiceLinkedRoleRequest.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_CLICKHOUSE_MODEL_CREATESERVICELINKEDROLEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESERVICELINKEDROLEREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT CreateServiceLinkedRoleRequest : public RpcServiceRequest {
+public:
+	CreateServiceLinkedRoleRequest();
+	~CreateServiceLinkedRoleRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_CREATESERVICELINKEDROLEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/CreateServiceLinkedRoleResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/DeleteAccountRequest.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_CLICKHOUSE_MODEL_DELETEACCOUNTREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEACCOUNTREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteAccountRequest : public RpcServiceRequest {
+public:
+	DeleteAccountRequest();
+	~DeleteAccountRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getAccountName() const;
+	void setAccountName(const std::string &accountName);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string accountName_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEACCOUNTREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DeleteAccountResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/DeleteDBClusterRequest.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_CLICKHOUSE_MODEL_DELETEDBCLUSTERREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEDBCLUSTERREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteDBClusterRequest : public RpcServiceRequest {
+public:
+	DeleteDBClusterRequest();
+	~DeleteDBClusterRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETEDBCLUSTERREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DeleteDBClusterResult.h

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

clickhouse/include/alibabacloud/clickhouse/model/DeleteSyndbRequest.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_CLICKHOUSE_MODEL_DELETESYNDBREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteSyndbRequest : public RpcServiceRequest {
+public:
+	DeleteSyndbRequest();
+	~DeleteSyndbRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getSynDb() const;
+	void setSynDb(const std::string &synDb);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDbClusterId() const;
+	void setDbClusterId(const std::string &dbClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string synDb_;
+	std::string accessKeyId_;
+	std::string resourceOwnerAccount_;
+	std::string dbClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DeleteSyndbResult.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_CLICKHOUSE_MODEL_DELETESYNDBRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT DeleteSyndbResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSyndbResult();
+				explicit DeleteSyndbResult(const std::string &payload);
+				~DeleteSyndbResult();
+				bool getStatus()const;
+				std::string getErrorMsg()const;
+				long getErrorCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool status_;
+				std::string errorMsg_;
+				long errorCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DELETESYNDBRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeAccountAuthorityRequest.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_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAccountAuthorityRequest : public RpcServiceRequest {
+public:
+	DescribeAccountAuthorityRequest();
+	~DescribeAccountAuthorityRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getAccountName() const;
+	void setAccountName(const std::string &accountName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string accountName_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeAccountAuthorityResult.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_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAccountAuthorityResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeAccountAuthorityResult();
+				explicit DescribeAccountAuthorityResult(const std::string &payload);
+				~DescribeAccountAuthorityResult();
+				bool getDdlAuthority()const;
+				std::string getDmlAuthority()const;
+				std::vector<std::string> getTotalDatabases()const;
+				std::vector<std::string> getTotalDictionaries()const;
+				std::vector<std::string> getAllowDictionaries()const;
+				std::vector<std::string> getAllowDatabases()const;
+				std::string getAccountName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool ddlAuthority_;
+				std::string dmlAuthority_;
+				std::vector<std::string> totalDatabases_;
+				std::vector<std::string> totalDictionaries_;
+				std::vector<std::string> allowDictionaries_;
+				std::vector<std::string> allowDatabases_;
+				std::string accountName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTAUTHORITYRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeAccountsRequest.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_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSREQUEST_H_
+
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Clickhouse {
+namespace Model {
+class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAccountsRequest : public RpcServiceRequest {
+public:
+	DescribeAccountsRequest();
+	~DescribeAccountsRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getAccountName() const;
+	void setAccountName(const std::string &accountName);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	int pageNumber_;
+	std::string accessKeyId_;
+	std::string accountName_;
+	int pageSize_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeAccountsResult.h

@@ -0,0 +1,65 @@
+/*
+ * 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_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/clickhouse/ClickhouseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Clickhouse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLICKHOUSE_EXPORT DescribeAccountsResult : public ServiceResult
+			{
+			public:
+				struct Account
+				{
+					std::string accountDescription;
+					std::string accountStatus;
+					std::string accountType;
+					std::string configType;
+					std::string accountName;
+				};
+
+
+				DescribeAccountsResult();
+				explicit DescribeAccountsResult(const std::string &payload);
+				~DescribeAccountsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<Account> getAccounts()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<Account> accounts_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEACCOUNTSRESULT_H_