Support restart node list and re-elect zookeeper.

VERSION

@@ -1 +1 @@
-1.36.2076
+1.36.2077

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_

clickhouse/include/alibabacloud/clickhouse/model/DescribeAllDataSourceRequest.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_DESCRIBEALLDATASOURCEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCEREQUEST_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 DescribeAllDataSourceRequest : public RpcServiceRequest {
+public:
+	DescribeAllDataSourceRequest();
+	~DescribeAllDataSourceRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getTableName() const;
+	void setTableName(const std::string &tableName);
+	std::string getSchemaName() const;
+	void setSchemaName(const std::string &schemaName);
+	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 tableName_;
+	std::string schemaName_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeAllDataSourceResult.h

@@ -0,0 +1,76 @@
+/*
+ * 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_DESCRIBEALLDATASOURCERESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCERESULT_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 DescribeAllDataSourceResult : public ServiceResult
+			{
+			public:
+				struct Table
+				{
+					std::string tableName;
+					std::string dBClusterId;
+					std::string schemaName;
+				};
+				struct Column
+				{
+					std::string columnName;
+					std::string tableName;
+					std::string type;
+					bool autoIncrementColumn;
+					std::string dBClusterId;
+					bool primaryKey;
+					std::string schemaName;
+				};
+				struct Schema
+				{
+					std::string dBClusterId;
+					std::string schemaName;
+				};
+
+
+				DescribeAllDataSourceResult();
+				explicit DescribeAllDataSourceResult(const std::string &payload);
+				~DescribeAllDataSourceResult();
+				std::vector<Table> getTables()const;
+				std::vector<Column> getColumns()const;
+				std::vector<Schema> getSchemas()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Table> tables_;
+				std::vector<Column> columns_;
+				std::vector<Schema> schemas_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCERESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeAllDataSourcesRequest.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_DESCRIBEALLDATASOURCESREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESREQUEST_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 DescribeAllDataSourcesRequest : public RpcServiceRequest {
+public:
+	DescribeAllDataSourcesRequest();
+	~DescribeAllDataSourcesRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getTableName() const;
+	void setTableName(const std::string &tableName);
+	std::string getSchemaName() const;
+	void setSchemaName(const std::string &schemaName);
+	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 tableName_;
+	std::string schemaName_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeAllDataSourcesResult.h

@@ -0,0 +1,76 @@
+/*
+ * 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_DESCRIBEALLDATASOURCESRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESRESULT_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 DescribeAllDataSourcesResult : public ServiceResult
+			{
+			public:
+				struct Table
+				{
+					std::string tableName;
+					std::string dBClusterId;
+					std::string schemaName;
+				};
+				struct Column
+				{
+					std::string columnName;
+					std::string tableName;
+					std::string type;
+					bool autoIncrementColumn;
+					std::string dBClusterId;
+					bool primaryKey;
+					std::string schemaName;
+				};
+				struct Schema
+				{
+					std::string dBClusterId;
+					std::string schemaName;
+				};
+
+
+				DescribeAllDataSourcesResult();
+				explicit DescribeAllDataSourcesResult(const std::string &payload);
+				~DescribeAllDataSourcesResult();
+				std::vector<Table> getTables()const;
+				std::vector<Column> getColumns()const;
+				std::vector<Schema> getSchemas()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Table> tables_;
+				std::vector<Column> columns_;
+				std::vector<Schema> schemas_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEALLDATASOURCESRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeBackupPolicyRequest.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_DESCRIBEBACKUPPOLICYREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYREQUEST_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 DescribeBackupPolicyRequest : public RpcServiceRequest {
+public:
+	DescribeBackupPolicyRequest();
+	~DescribeBackupPolicyRequest();
+	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_DESCRIBEBACKUPPOLICYREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeBackupPolicyResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYRESULT_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 DescribeBackupPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeBackupPolicyResult();
+				explicit DescribeBackupPolicyResult(const std::string &payload);
+				~DescribeBackupPolicyResult();
+				std::string getPreferredBackupPeriod()const;
+				std::string get_Switch()const;
+				std::string getPreferredBackupTime()const;
+				std::string getBackupSize()const;
+				int getBackupRetentionPeriod()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string preferredBackupPeriod_;
+				std::string _switch_;
+				std::string preferredBackupTime_;
+				std::string backupSize_;
+				int backupRetentionPeriod_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeBackupsRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSREQUEST_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 DescribeBackupsRequest : public RpcServiceRequest {
+public:
+	DescribeBackupsRequest();
+	~DescribeBackupsRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	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);
+	std::string getBackupId() const;
+	void setBackupId(const std::string &backupId);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string startTime_;
+	int pageNumber_;
+	std::string accessKeyId_;
+	int pageSize_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	std::string backupId_;
+	std::string endTime_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeBackupsResult.h

@@ -0,0 +1,70 @@
+/*
+ * 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_DESCRIBEBACKUPSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSRESULT_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 DescribeBackupsResult : public ServiceResult
+			{
+			public:
+				struct Backup
+				{
+					std::string backupMethod;
+					std::string expireDate;
+					long backupSize;
+					std::string backupEndTime;
+					std::string backupSetInfo;
+					std::string dBClusterId;
+					std::string backupStartTime;
+					std::string backupType;
+					std::string backupId;
+					std::string backupStatus;
+				};
+
+
+				DescribeBackupsResult();
+				explicit DescribeBackupsResult(const std::string &payload);
+				~DescribeBackupsResult();
+				std::string getTotalCount()const;
+				std::string getPageSize()const;
+				std::string getPageNumber()const;
+				std::vector<Backup> getItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string totalCount_;
+				std::string pageSize_;
+				std::string pageNumber_;
+				std::vector<Backup> items_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEBACKUPSRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeColumnsRequest.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_DESCRIBECOLUMNSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSREQUEST_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 DescribeColumnsRequest : public RpcServiceRequest {
+public:
+	DescribeColumnsRequest();
+	~DescribeColumnsRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getTableName() const;
+	void setTableName(const std::string &tableName);
+	std::string getSchemaName() const;
+	void setSchemaName(const std::string &schemaName);
+	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 tableName_;
+	std::string schemaName_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeColumnsResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSRESULT_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 DescribeColumnsResult : public ServiceResult
+			{
+			public:
+				struct Column
+				{
+					std::string columnName;
+					std::string tableName;
+					std::string type;
+					bool autoIncrementColumn;
+					std::string dBClusterId;
+					bool primaryKey;
+					std::string schemaName;
+				};
+
+
+				DescribeColumnsResult();
+				explicit DescribeColumnsResult(const std::string &payload);
+				~DescribeColumnsResult();
+				std::vector<Column> getItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Column> items_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECOLUMNSRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeConfigHistoryRequest.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_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYREQUEST_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 DescribeConfigHistoryRequest : public RpcServiceRequest {
+public:
+	DescribeConfigHistoryRequest();
+	~DescribeConfigHistoryRequest();
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+
+private:
+	std::string startTime_;
+	std::string dBClusterId_;
+	std::string endTime_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeConfigHistoryResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYRESULT_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 DescribeConfigHistoryResult : public ServiceResult
+			{
+			public:
+				struct ConfigHistoryItem
+				{
+					std::string changeId;
+					std::string ownerId;
+					std::string time;
+					std::string reason;
+					bool success;
+				};
+
+
+				DescribeConfigHistoryResult();
+				explicit DescribeConfigHistoryResult(const std::string &payload);
+				~DescribeConfigHistoryResult();
+				std::vector<ConfigHistoryItem> getConfigHistoryItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ConfigHistoryItem> configHistoryItems_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGHISTORYRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeConfigVersionDifferenceRequest.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_DESCRIBECONFIGVERSIONDIFFERENCEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCEREQUEST_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 DescribeConfigVersionDifferenceRequest : public RpcServiceRequest {
+public:
+	DescribeConfigVersionDifferenceRequest();
+	~DescribeConfigVersionDifferenceRequest();
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getChangeId() const;
+	void setChangeId(const std::string &changeId);
+
+private:
+	std::string dBClusterId_;
+	std::string changeId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeConfigVersionDifferenceResult.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_DESCRIBECONFIGVERSIONDIFFERENCERESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCERESULT_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 DescribeConfigVersionDifferenceResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeConfigVersionDifferenceResult();
+				explicit DescribeConfigVersionDifferenceResult(const std::string &payload);
+				~DescribeConfigVersionDifferenceResult();
+				std::string getOldConfigXML()const;
+				std::string getNewConfigXML()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string oldConfigXML_;
+				std::string newConfigXML_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBECONFIGVERSIONDIFFERENCERESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterAccessWhiteListRequest.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_DESCRIBEDBCLUSTERACCESSWHITELISTREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTREQUEST_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 DescribeDBClusterAccessWhiteListRequest : public RpcServiceRequest {
+public:
+	DescribeDBClusterAccessWhiteListRequest();
+	~DescribeDBClusterAccessWhiteListRequest();
+	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_DESCRIBEDBCLUSTERACCESSWHITELISTREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterAccessWhiteListResult.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_DESCRIBEDBCLUSTERACCESSWHITELISTRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTRESULT_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 DescribeDBClusterAccessWhiteListResult : public ServiceResult
+			{
+			public:
+				struct IPArray
+				{
+					std::string securityIPList;
+					std::string dBClusterIPArrayName;
+					std::string dBClusterIPArrayAttribute;
+				};
+
+
+				DescribeDBClusterAccessWhiteListResult();
+				explicit DescribeDBClusterAccessWhiteListResult(const std::string &payload);
+				~DescribeDBClusterAccessWhiteListResult();
+				std::vector<IPArray> getDBClusterAccessWhiteList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<IPArray> dBClusterAccessWhiteList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterAttributeRequest.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_DESCRIBEDBCLUSTERATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERATTRIBUTEREQUEST_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 DescribeDBClusterAttributeRequest : public RpcServiceRequest {
+public:
+	DescribeDBClusterAttributeRequest();
+	~DescribeDBClusterAttributeRequest();
+	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_DESCRIBEDBCLUSTERATTRIBUTEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterAttributeResult.h

@@ -0,0 +1,120 @@
+/*
+ * 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_DESCRIBEDBCLUSTERATTRIBUTERESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERATTRIBUTERESULT_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 DescribeDBClusterAttributeResult : public ServiceResult
+			{
+			public:
+				struct DBCluster
+				{
+					struct ScaleOutStatus
+					{
+						std::string progress;
+						std::string ratio;
+					};
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					std::string engineMinorVersion;
+					std::string resourceGroupId;
+					std::string controlVersion;
+					std::string vpcIpAddr;
+					int port;
+					std::string dBClusterType;
+					std::string zookeeperClass;
+					std::string appointmentRestartNodeList;
+					int supportBackup;
+					long dBNodeCount;
+					std::string publicConnectionString;
+					std::string lockReason;
+					int extStorageSize;
+					std::vector<Tag> tags;
+					std::string engine;
+					bool appointmentElectZookeeperDisableWrite;
+					long dBNodeStorage;
+					std::string encryptionType;
+					std::string isExpired;
+					std::string storageType;
+					std::string engineVersion;
+					std::string vSwitchId;
+					std::string dBClusterDescription;
+					std::string payType;
+					std::string lockMode;
+					ScaleOutStatus scaleOutStatus;
+					std::string vpcId;
+					std::string vpcCloudInstanceId;
+					std::string zoneIdVswitchMap;
+					bool supportMysqlPort;
+					std::string connectionString;
+					std::string expireTime;
+					std::string category;
+					std::string engineLatestMinorVersion;
+					bool maintainAutoType;
+					std::string dBClusterId;
+					std::string encryptionKey;
+					std::string dBClusterNetworkType;
+					std::string extStorageType;
+					std::string availableUpgradeMajorVersion;
+					std::string commodityCode;
+					int supportOss;
+					bool supportHttpsPort;
+					std::string bid;
+					std::string maintainTime;
+					std::string appointmentElectZookeeperTime;
+					std::string zoneId;
+					std::string publicIpAddr;
+					std::string dBClusterStatus;
+					std::string createTime;
+					std::string dBNodeClass;
+					std::string regionId;
+					std::string appointmentRestartNodeTime;
+					std::string publicPort;
+					std::string aliUid;
+					std::string appointmentRestartTime;
+				};
+
+
+				DescribeDBClusterAttributeResult();
+				explicit DescribeDBClusterAttributeResult(const std::string &payload);
+				~DescribeDBClusterAttributeResult();
+				DBCluster getDBCluster()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				DBCluster dBCluster_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERATTRIBUTERESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterConfigInXMLRequest.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_DESCRIBEDBCLUSTERCONFIGINXMLREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLREQUEST_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 DescribeDBClusterConfigInXMLRequest : public RpcServiceRequest {
+public:
+	DescribeDBClusterConfigInXMLRequest();
+	~DescribeDBClusterConfigInXMLRequest();
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string dBClusterId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterConfigInXMLResult.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_DESCRIBEDBCLUSTERCONFIGINXMLRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLRESULT_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 DescribeDBClusterConfigInXMLResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDBClusterConfigInXMLResult();
+				explicit DescribeDBClusterConfigInXMLResult(const std::string &payload);
+				~DescribeDBClusterConfigInXMLResult();
+				std::string getConfig()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string config_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGINXMLRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterConfigRequest.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_DESCRIBEDBCLUSTERCONFIGREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGREQUEST_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 DescribeDBClusterConfigRequest : public RpcServiceRequest {
+public:
+	DescribeDBClusterConfigRequest();
+	~DescribeDBClusterConfigRequest();
+	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_DESCRIBEDBCLUSTERCONFIGREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterConfigResult.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_DESCRIBEDBCLUSTERCONFIGRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGRESULT_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 DescribeDBClusterConfigResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDBClusterConfigResult();
+				explicit DescribeDBClusterConfigResult(const std::string &payload);
+				~DescribeDBClusterConfigResult();
+				std::string getConfig()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string config_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERCONFIGRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterNetInfoItemsRequest.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_DESCRIBEDBCLUSTERNETINFOITEMSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERNETINFOITEMSREQUEST_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 DescribeDBClusterNetInfoItemsRequest : public RpcServiceRequest {
+public:
+	DescribeDBClusterNetInfoItemsRequest();
+	~DescribeDBClusterNetInfoItemsRequest();
+	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_DESCRIBEDBCLUSTERNETINFOITEMSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterNetInfoItemsResult.h

@@ -0,0 +1,67 @@
+/*
+ * 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_DESCRIBEDBCLUSTERNETINFOITEMSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERNETINFOITEMSRESULT_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 DescribeDBClusterNetInfoItemsResult : public ServiceResult
+			{
+			public:
+				struct NetInfoItem
+				{
+					std::string httpPort;
+					std::string vpcId;
+					std::string mySQLPort;
+					std::string jdbcPort;
+					std::string vSwitchId;
+					std::string connectionString;
+					std::string iPAddress;
+					std::string netType;
+					std::string httpsPort;
+				};
+
+
+				DescribeDBClusterNetInfoItemsResult();
+				explicit DescribeDBClusterNetInfoItemsResult(const std::string &payload);
+				~DescribeDBClusterNetInfoItemsResult();
+				std::vector<NetInfoItem> getNetInfoItems()const;
+				std::string getClusterNetworkType()const;
+				bool getEnableSLB()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<NetInfoItem> netInfoItems_;
+				std::string clusterNetworkType_;
+				bool enableSLB_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERNETINFOITEMSRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterPerformanceRequest.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_DESCRIBEDBCLUSTERPERFORMANCEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCEREQUEST_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 DescribeDBClusterPerformanceRequest : public RpcServiceRequest {
+public:
+	DescribeDBClusterPerformanceRequest();
+	~DescribeDBClusterPerformanceRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getKey() const;
+	void setKey(const std::string &key);
+	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 getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string startTime_;
+	std::string accessKeyId_;
+	std::string key_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	std::string endTime_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClusterPerformanceResult.h

@@ -0,0 +1,73 @@
+/*
+ * 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_DESCRIBEDBCLUSTERPERFORMANCERESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCERESULT_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 DescribeDBClusterPerformanceResult : public ServiceResult
+			{
+			public:
+				struct PerformanceItem
+				{
+					struct SeriesItem
+					{
+						struct ValueItem
+						{
+							std::vector<std::string> point;
+						};
+						std::vector<SeriesItem::ValueItem> values;
+						std::string name;
+					};
+					std::vector<PerformanceItem::SeriesItem> series;
+					std::string unit;
+					std::string key;
+					std::string name;
+				};
+
+
+				DescribeDBClusterPerformanceResult();
+				explicit DescribeDBClusterPerformanceResult(const std::string &payload);
+				~DescribeDBClusterPerformanceResult();
+				std::string getEndTime()const;
+				std::string getStartTime()const;
+				std::string getDBClusterId()const;
+				std::vector<PerformanceItem> getPerformances()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string startTime_;
+				std::string dBClusterId_;
+				std::vector<PerformanceItem> performances_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERPERFORMANCERESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClustersRequest.h

@@ -0,0 +1,85 @@
+/*
+ * 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_DESCRIBEDBCLUSTERSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSREQUEST_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 DescribeDBClustersRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	DescribeDBClustersRequest();
+	~DescribeDBClustersRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getDBClusterDescription() const;
+	void setDBClusterDescription(const std::string &dBClusterDescription);
+	std::string getDBClusterStatus() const;
+	void setDBClusterStatus(const std::string &dBClusterStatus);
+	std::string getControlVersion() const;
+	void setControlVersion(const std::string &controlVersion);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getDBClusterIds() const;
+	void setDBClusterIds(const std::string &dBClusterIds);
+
+private:
+	long resourceOwnerId_;
+	std::string dBClusterDescription_;
+	std::string dBClusterStatus_;
+	std::string controlVersion_;
+	int pageNumber_;
+	std::string accessKeyId_;
+	std::string resourceGroupId_;
+	std::string regionId_;
+	int pageSize_;
+	std::vector<Tag> tag_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string dBClusterIds_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBClustersResult.h

@@ -0,0 +1,103 @@
+/*
+ * 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_DESCRIBEDBCLUSTERSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSRESULT_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 DescribeDBClustersResult : public ServiceResult
+			{
+			public:
+				struct DBCluster
+				{
+					struct ScaleOutStatus
+					{
+						std::string progress;
+						std::string ratio;
+					};
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					std::string category;
+					std::string resourceGroupId;
+					std::string controlVersion;
+					int port;
+					std::string dBClusterId;
+					std::string dBClusterNetworkType;
+					std::string extStorageType;
+					std::string dbVersion;
+					long dBNodeCount;
+					std::string commodityCode;
+					std::string bid;
+					std::string lockReason;
+					int extStorageSize;
+					std::vector<DBCluster::Tag> tags;
+					long dBNodeStorage;
+					std::string isExpired;
+					std::string storageType;
+					std::string zoneId;
+					std::string dBClusterStatus;
+					std::string createTime;
+					std::string vSwitchId;
+					std::string scaleOutDisableWriteWindows;
+					std::string dBClusterDescription;
+					std::string payType;
+					std::string lockMode;
+					std::string dBNodeClass;
+					ScaleOutStatus scaleOutStatus;
+					std::string vpcId;
+					std::string vpcCloudInstanceId;
+					std::string regionId;
+					std::string connectionString;
+					std::string expireTime;
+					std::string aliUid;
+				};
+
+
+				DescribeDBClustersResult();
+				explicit DescribeDBClustersResult(const std::string &payload);
+				~DescribeDBClustersResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<DBCluster> getDBClusters()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<DBCluster> dBClusters_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCLUSTERSRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBConfigRequest.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_DESCRIBEDBCONFIGREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCONFIGREQUEST_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 DescribeDBConfigRequest : public RpcServiceRequest {
+public:
+	DescribeDBConfigRequest();
+	~DescribeDBConfigRequest();
+	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_DESCRIBEDBCONFIGREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeDBConfigResult.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_DESCRIBEDBCONFIGRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCONFIGRESULT_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 DescribeDBConfigResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDBConfigResult();
+				explicit DescribeDBConfigResult(const std::string &payload);
+				~DescribeDBConfigResult();
+				std::string getConfig()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string config_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEDBCONFIGRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeOSSStorageRequest.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_DESCRIBEOSSSTORAGEREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEOSSSTORAGEREQUEST_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 DescribeOSSStorageRequest : public RpcServiceRequest {
+public:
+	DescribeOSSStorageRequest();
+	~DescribeOSSStorageRequest();
+	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_DESCRIBEOSSSTORAGEREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeOSSStorageResult.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_DESCRIBEOSSSTORAGERESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEOSSSTORAGERESULT_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 DescribeOSSStorageResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeOSSStorageResult();
+				explicit DescribeOSSStorageResult(const std::string &payload);
+				~DescribeOSSStorageResult();
+				std::string getPolicy()const;
+				std::string getState()const;
+				bool getColdStorage()const;
+				std::string getStorageUsage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string policy_;
+				std::string state_;
+				bool coldStorage_;
+				std::string storageUsage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEOSSSTORAGERESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeProcessListRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTREQUEST_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 DescribeProcessListRequest : public RpcServiceRequest {
+public:
+	DescribeProcessListRequest();
+	~DescribeProcessListRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getInitialQueryId() const;
+	void setInitialQueryId(const std::string &initialQueryId);
+	int getQueryDurationMs() const;
+	void setQueryDurationMs(int queryDurationMs);
+	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 getInitialUser() const;
+	void setInitialUser(const std::string &initialUser);
+	std::string getKeyword() const;
+	void setKeyword(const std::string &keyword);
+	std::string getOrder() const;
+	void setOrder(const std::string &order);
+	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 initialQueryId_;
+	int queryDurationMs_;
+	int pageNumber_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	int pageSize_;
+	std::string initialUser_;
+	std::string keyword_;
+	std::string order_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeProcessListResult.h

@@ -0,0 +1,79 @@
+/*
+ * 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_DESCRIBEPROCESSLISTRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTRESULT_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 DescribeProcessListResult : public ServiceResult
+			{
+			public:
+				struct ProcessList
+				{
+					struct Statistics
+					{
+						float elapsedTime;
+						int bytesRead;
+						int rowsRead;
+					};
+					struct ResultSet
+					{
+						std::string type;
+						std::string name;
+					};
+					struct ResultSet1
+					{
+						std::string initialUser;
+						std::string query;
+						std::string initialAddress;
+						std::string initialQueryId;
+						std::string queryDurationMs;
+						std::string queryStartTime;
+					};
+					std::string rowsBeforeLimitAtLeast;
+					std::vector<ResultSet> tableSchema;
+					std::vector<ResultSet1> data;
+					Statistics statistics;
+					std::string rows;
+				};
+
+
+				DescribeProcessListResult();
+				explicit DescribeProcessListResult(const std::string &payload);
+				~DescribeProcessListResult();
+				ProcessList getProcessList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ProcessList processList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEPROCESSLISTRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeRegionsRequest.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_DESCRIBEREGIONSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSREQUEST_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 DescribeRegionsRequest : public RpcServiceRequest {
+public:
+	DescribeRegionsRequest();
+	~DescribeRegionsRequest();
+	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_DESCRIBEREGIONSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeRegionsResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSRESULT_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 DescribeRegionsResult : public ServiceResult
+			{
+			public:
+				struct Region
+				{
+					struct Zone
+					{
+						bool vpcEnabled;
+						std::string zoneId;
+					};
+					std::string regionId;
+					std::vector<Region::Zone> zones;
+				};
+
+
+				DescribeRegionsResult();
+				explicit DescribeRegionsResult(const std::string &payload);
+				~DescribeRegionsResult();
+				std::vector<Region> getRegions()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Region> regions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBEREGIONSRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeSchemasRequest.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_DESCRIBESCHEMASREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASREQUEST_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 DescribeSchemasRequest : public RpcServiceRequest {
+public:
+	DescribeSchemasRequest();
+	~DescribeSchemasRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getTableName() const;
+	void setTableName(const std::string &tableName);
+	std::string getSchemaName() const;
+	void setSchemaName(const std::string &schemaName);
+	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 tableName_;
+	std::string schemaName_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeSchemasResult.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASRESULT_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 DescribeSchemasResult : public ServiceResult
+			{
+			public:
+				struct Schema
+				{
+					std::string dBClusterId;
+					std::string schemaName;
+				};
+
+
+				DescribeSchemasResult();
+				explicit DescribeSchemasResult(const std::string &payload);
+				~DescribeSchemasResult();
+				std::vector<Schema> getItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Schema> items_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESCHEMASRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeSlowLogRecordsRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSREQUEST_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 DescribeSlowLogRecordsRequest : public RpcServiceRequest {
+public:
+	DescribeSlowLogRecordsRequest();
+	~DescribeSlowLogRecordsRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	int getQueryDurationMs() const;
+	void setQueryDurationMs(int queryDurationMs);
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	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);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	int queryDurationMs_;
+	std::string startTime_;
+	int pageNumber_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	int pageSize_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	std::string endTime_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeSlowLogRecordsResult.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_DESCRIBESLOWLOGRECORDSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSRESULT_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 DescribeSlowLogRecordsResult : public ServiceResult
+			{
+			public:
+				struct SlowLogRecords
+				{
+					struct Statistics
+					{
+						float elapsedTime;
+						int bytesRead;
+						int rowsRead;
+					};
+					struct ResultSet
+					{
+						std::string type;
+						std::string name;
+					};
+					struct ResultSet1
+					{
+						std::string initialUser;
+						std::string type;
+						std::string query;
+						std::string initialAddress;
+						std::string initialQueryId;
+						std::string queryDurationMs;
+						std::string readBytes;
+						std::string readRows;
+						std::string queryStartTime;
+						std::string memoryUsage;
+						std::string resultBytes;
+					};
+					std::string rowsBeforeLimitAtLeast;
+					std::vector<ResultSet> tableSchema;
+					std::vector<ResultSet1> data;
+					Statistics statistics;
+					std::string rows;
+				};
+
+
+				DescribeSlowLogRecordsResult();
+				explicit DescribeSlowLogRecordsResult(const std::string &payload);
+				~DescribeSlowLogRecordsResult();
+				SlowLogRecords getSlowLogRecords()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				SlowLogRecords slowLogRecords_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESLOWLOGRECORDSRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeSynDbTablesRequest.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_DESCRIBESYNDBTABLESREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBTABLESREQUEST_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 DescribeSynDbTablesRequest : public RpcServiceRequest {
+public:
+	DescribeSynDbTablesRequest();
+	~DescribeSynDbTablesRequest();
+	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_DESCRIBESYNDBTABLESREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeSynDbTablesResult.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_DESCRIBESYNDBTABLESRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBTABLESRESULT_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 DescribeSynDbTablesResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeSynDbTablesResult();
+				explicit DescribeSynDbTablesResult(const std::string &payload);
+				~DescribeSynDbTablesResult();
+				std::vector<std::string> getTables()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> tables_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBTABLESRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeSynDbsRequest.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_DESCRIBESYNDBSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSREQUEST_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 DescribeSynDbsRequest : public RpcServiceRequest {
+public:
+	DescribeSynDbsRequest();
+	~DescribeSynDbsRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	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_;
+	int pageSize_;
+	std::string resourceOwnerAccount_;
+	std::string dbClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeSynDbsResult.h

@@ -0,0 +1,67 @@
+/*
+ * 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_DESCRIBESYNDBSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSRESULT_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 DescribeSynDbsResult : public ServiceResult
+			{
+			public:
+				struct SynDb
+				{
+					std::string rdsVpcUrl;
+					std::string rdsUserName;
+					bool synStatus;
+					std::string errorMsg;
+					std::string synDb;
+					std::string rdsId;
+					std::string rdsPassword;
+				};
+
+
+				DescribeSynDbsResult();
+				explicit DescribeSynDbsResult(const std::string &payload);
+				~DescribeSynDbsResult();
+				int getTotalCount()const;
+				std::vector<SynDb> getSynDbs()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<SynDb> synDbs_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBESYNDBSRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeTablesRequest.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_DESCRIBETABLESREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESREQUEST_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 DescribeTablesRequest : public RpcServiceRequest {
+public:
+	DescribeTablesRequest();
+	~DescribeTablesRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getTableName() const;
+	void setTableName(const std::string &tableName);
+	std::string getSchemaName() const;
+	void setSchemaName(const std::string &schemaName);
+	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 tableName_;
+	std::string schemaName_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeTablesResult.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_DESCRIBETABLESRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESRESULT_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 DescribeTablesResult : public ServiceResult
+			{
+			public:
+				struct Table
+				{
+					std::string tableName;
+					std::string dBClusterId;
+					std::string schemaName;
+				};
+
+
+				DescribeTablesResult();
+				explicit DescribeTablesResult(const std::string &payload);
+				~DescribeTablesResult();
+				std::vector<Table> getItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Table> items_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETABLESRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeTransferHistoryRequest.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_DESCRIBETRANSFERHISTORYREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETRANSFERHISTORYREQUEST_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 DescribeTransferHistoryRequest : public RpcServiceRequest {
+public:
+	DescribeTransferHistoryRequest();
+	~DescribeTransferHistoryRequest();
+	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_DESCRIBETRANSFERHISTORYREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/DescribeTransferHistoryResult.h

@@ -0,0 +1,67 @@
+/*
+ * 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_DESCRIBETRANSFERHISTORYRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETRANSFERHISTORYRESULT_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 DescribeTransferHistoryResult : public ServiceResult
+			{
+			public:
+				struct HistoryDetail
+				{
+					std::string targetDBCluster;
+					std::string status;
+					long unsyncedBytes;
+					std::string progress;
+					std::string targetControlVersion;
+					std::string sourceDBCluster;
+					std::string disableWriteWindows;
+					std::string sourceControlVersion;
+					std::string subJobStatus;
+					long bytesPerMinute;
+					long unsyncedParts;
+					std::string subJob;
+					double partsPerMinute;
+				};
+
+
+				DescribeTransferHistoryResult();
+				explicit DescribeTransferHistoryResult(const std::string &payload);
+				~DescribeTransferHistoryResult();
+				std::vector<HistoryDetail> getHistoryDetails()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<HistoryDetail> historyDetails_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_DESCRIBETRANSFERHISTORYRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/KillProcessRequest.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_KILLPROCESSREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_KILLPROCESSREQUEST_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 KillProcessRequest : public RpcServiceRequest {
+public:
+	KillProcessRequest();
+	~KillProcessRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getInitialQueryId() const;
+	void setInitialQueryId(const std::string &initialQueryId);
+	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 initialQueryId_;
+	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_KILLPROCESSREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/KillProcessResult.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_KILLPROCESSRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_KILLPROCESSRESULT_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 KillProcessResult : public ServiceResult
+			{
+			public:
+
+
+				KillProcessResult();
+				explicit KillProcessResult(const std::string &payload);
+				~KillProcessResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_KILLPROCESSRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/ModifyAccountAuthorityRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYREQUEST_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 ModifyAccountAuthorityRequest : public RpcServiceRequest {
+public:
+	ModifyAccountAuthorityRequest();
+	~ModifyAccountAuthorityRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getTotalDictionaries() const;
+	void setTotalDictionaries(const std::string &totalDictionaries);
+	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);
+	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 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_;
+	bool ddlAuthority_;
+	std::string totalDatabases_;
+};
+} // namespace Model
+} // namespace Clickhouse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/ModifyAccountAuthorityResult.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_MODIFYACCOUNTAUTHORITYRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYRESULT_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 ModifyAccountAuthorityResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyAccountAuthorityResult();
+				explicit ModifyAccountAuthorityResult(const std::string &payload);
+				~ModifyAccountAuthorityResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTAUTHORITYRESULT_H_

clickhouse/include/alibabacloud/clickhouse/model/ModifyAccountDescriptionRequest.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_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_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 ModifyAccountDescriptionRequest : public RpcServiceRequest {
+public:
+	ModifyAccountDescriptionRequest();
+	~ModifyAccountDescriptionRequest();
+	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);
+
+private:
+	long resourceOwnerId_;
+	std::string accountDescription_;
+	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_MODIFYACCOUNTDESCRIPTIONREQUEST_H_

clickhouse/include/alibabacloud/clickhouse/model/ModifyAccountDescriptionResult.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_MODIFYACCOUNTDESCRIPTIONRESULT_H_
+#define ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTDESCRIPTIONRESULT_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 ModifyAccountDescriptionResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyAccountDescriptionResult();
+				explicit ModifyAccountDescriptionResult(const std::string &payload);
+				~ModifyAccountDescriptionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLICKHOUSE_MODEL_MODIFYACCOUNTDESCRIPTIONRESULT_H_