Generated 2023-05-22 for selectdb.

VERSION

@@ -1 +1 @@
-1.36.2028
+1.36.2029

selectdb/CMakeLists.txt

@@ -0,0 +1,214 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(selectdb_public_header 
+	include/alibabacloud/selectdb/SelectdbClient.h
+	include/alibabacloud/selectdb/SelectdbExport.h )
+
+set(selectdb_public_header_model 
+	include/alibabacloud/selectdb/model/AllocateInstancePublicConnectionRequest.h
+	include/alibabacloud/selectdb/model/AllocateInstancePublicConnectionResult.h
+	include/alibabacloud/selectdb/model/CheckCreateDBInstanceRequest.h
+	include/alibabacloud/selectdb/model/CheckCreateDBInstanceResult.h
+	include/alibabacloud/selectdb/model/CheckServiceLinkedRoleRequest.h
+	include/alibabacloud/selectdb/model/CheckServiceLinkedRoleResult.h
+	include/alibabacloud/selectdb/model/CreateDBClusterRequest.h
+	include/alibabacloud/selectdb/model/CreateDBClusterResult.h
+	include/alibabacloud/selectdb/model/CreateDBInstanceRequest.h
+	include/alibabacloud/selectdb/model/CreateDBInstanceResult.h
+	include/alibabacloud/selectdb/model/CreateElasticRuleRequest.h
+	include/alibabacloud/selectdb/model/CreateElasticRuleResult.h
+	include/alibabacloud/selectdb/model/CreateServiceLinkedRoleForSelectDBRequest.h
+	include/alibabacloud/selectdb/model/CreateServiceLinkedRoleForSelectDBResult.h
+	include/alibabacloud/selectdb/model/DeleteDBClusterRequest.h
+	include/alibabacloud/selectdb/model/DeleteDBClusterResult.h
+	include/alibabacloud/selectdb/model/DeleteDBInstanceRequest.h
+	include/alibabacloud/selectdb/model/DeleteDBInstanceResult.h
+	include/alibabacloud/selectdb/model/DeleteElasticRuleRequest.h
+	include/alibabacloud/selectdb/model/DeleteElasticRuleResult.h
+	include/alibabacloud/selectdb/model/DescribeAllDBInstanceClassRequest.h
+	include/alibabacloud/selectdb/model/DescribeAllDBInstanceClassResult.h
+	include/alibabacloud/selectdb/model/DescribeDBClusterConfigRequest.h
+	include/alibabacloud/selectdb/model/DescribeDBClusterConfigResult.h
+	include/alibabacloud/selectdb/model/DescribeDBClusterConfigChangeLogsRequest.h
+	include/alibabacloud/selectdb/model/DescribeDBClusterConfigChangeLogsResult.h
+	include/alibabacloud/selectdb/model/DescribeDBInstanceAttributeRequest.h
+	include/alibabacloud/selectdb/model/DescribeDBInstanceAttributeResult.h
+	include/alibabacloud/selectdb/model/DescribeDBInstanceNetInfoRequest.h
+	include/alibabacloud/selectdb/model/DescribeDBInstanceNetInfoResult.h
+	include/alibabacloud/selectdb/model/DescribeDBInstancesRequest.h
+	include/alibabacloud/selectdb/model/DescribeDBInstancesResult.h
+	include/alibabacloud/selectdb/model/DescribeElasticRulesRequest.h
+	include/alibabacloud/selectdb/model/DescribeElasticRulesResult.h
+	include/alibabacloud/selectdb/model/DescribeSecurityIPListRequest.h
+	include/alibabacloud/selectdb/model/DescribeSecurityIPListResult.h
+	include/alibabacloud/selectdb/model/EnDisableScalingRulesRequest.h
+	include/alibabacloud/selectdb/model/EnDisableScalingRulesResult.h
+	include/alibabacloud/selectdb/model/GetCreateBEClusterInquiryRequest.h
+	include/alibabacloud/selectdb/model/GetCreateBEClusterInquiryResult.h
+	include/alibabacloud/selectdb/model/GetModifyBEClusterInquiryRequest.h
+	include/alibabacloud/selectdb/model/GetModifyBEClusterInquiryResult.h
+	include/alibabacloud/selectdb/model/ModifyBEClusterAttributeRequest.h
+	include/alibabacloud/selectdb/model/ModifyBEClusterAttributeResult.h
+	include/alibabacloud/selectdb/model/ModifyDBClusterRequest.h
+	include/alibabacloud/selectdb/model/ModifyDBClusterResult.h
+	include/alibabacloud/selectdb/model/ModifyDBClusterConfigRequest.h
+	include/alibabacloud/selectdb/model/ModifyDBClusterConfigResult.h
+	include/alibabacloud/selectdb/model/ModifyDBInstanceAttributeRequest.h
+	include/alibabacloud/selectdb/model/ModifyDBInstanceAttributeResult.h
+	include/alibabacloud/selectdb/model/ModifyElasticRuleRequest.h
+	include/alibabacloud/selectdb/model/ModifyElasticRuleResult.h
+	include/alibabacloud/selectdb/model/ModifySecurityIPListRequest.h
+	include/alibabacloud/selectdb/model/ModifySecurityIPListResult.h
+	include/alibabacloud/selectdb/model/ReleaseInstancePublicConnectionRequest.h
+	include/alibabacloud/selectdb/model/ReleaseInstancePublicConnectionResult.h
+	include/alibabacloud/selectdb/model/ResetAccountPasswordRequest.h
+	include/alibabacloud/selectdb/model/ResetAccountPasswordResult.h
+	include/alibabacloud/selectdb/model/RestartDBClusterRequest.h
+	include/alibabacloud/selectdb/model/RestartDBClusterResult.h
+	include/alibabacloud/selectdb/model/StartBEClusterRequest.h
+	include/alibabacloud/selectdb/model/StartBEClusterResult.h
+	include/alibabacloud/selectdb/model/StopBEClusterRequest.h
+	include/alibabacloud/selectdb/model/StopBEClusterResult.h
+	include/alibabacloud/selectdb/model/UpgradeDBInstanceEngineVersionRequest.h
+	include/alibabacloud/selectdb/model/UpgradeDBInstanceEngineVersionResult.h )
+
+set(selectdb_src 
+	src/SelectdbClient.cc
+	src/model/AllocateInstancePublicConnectionRequest.cc
+	src/model/AllocateInstancePublicConnectionResult.cc
+	src/model/CheckCreateDBInstanceRequest.cc
+	src/model/CheckCreateDBInstanceResult.cc
+	src/model/CheckServiceLinkedRoleRequest.cc
+	src/model/CheckServiceLinkedRoleResult.cc
+	src/model/CreateDBClusterRequest.cc
+	src/model/CreateDBClusterResult.cc
+	src/model/CreateDBInstanceRequest.cc
+	src/model/CreateDBInstanceResult.cc
+	src/model/CreateElasticRuleRequest.cc
+	src/model/CreateElasticRuleResult.cc
+	src/model/CreateServiceLinkedRoleForSelectDBRequest.cc
+	src/model/CreateServiceLinkedRoleForSelectDBResult.cc
+	src/model/DeleteDBClusterRequest.cc
+	src/model/DeleteDBClusterResult.cc
+	src/model/DeleteDBInstanceRequest.cc
+	src/model/DeleteDBInstanceResult.cc
+	src/model/DeleteElasticRuleRequest.cc
+	src/model/DeleteElasticRuleResult.cc
+	src/model/DescribeAllDBInstanceClassRequest.cc
+	src/model/DescribeAllDBInstanceClassResult.cc
+	src/model/DescribeDBClusterConfigRequest.cc
+	src/model/DescribeDBClusterConfigResult.cc
+	src/model/DescribeDBClusterConfigChangeLogsRequest.cc
+	src/model/DescribeDBClusterConfigChangeLogsResult.cc
+	src/model/DescribeDBInstanceAttributeRequest.cc
+	src/model/DescribeDBInstanceAttributeResult.cc
+	src/model/DescribeDBInstanceNetInfoRequest.cc
+	src/model/DescribeDBInstanceNetInfoResult.cc
+	src/model/DescribeDBInstancesRequest.cc
+	src/model/DescribeDBInstancesResult.cc
+	src/model/DescribeElasticRulesRequest.cc
+	src/model/DescribeElasticRulesResult.cc
+	src/model/DescribeSecurityIPListRequest.cc
+	src/model/DescribeSecurityIPListResult.cc
+	src/model/EnDisableScalingRulesRequest.cc
+	src/model/EnDisableScalingRulesResult.cc
+	src/model/GetCreateBEClusterInquiryRequest.cc
+	src/model/GetCreateBEClusterInquiryResult.cc
+	src/model/GetModifyBEClusterInquiryRequest.cc
+	src/model/GetModifyBEClusterInquiryResult.cc
+	src/model/ModifyBEClusterAttributeRequest.cc
+	src/model/ModifyBEClusterAttributeResult.cc
+	src/model/ModifyDBClusterRequest.cc
+	src/model/ModifyDBClusterResult.cc
+	src/model/ModifyDBClusterConfigRequest.cc
+	src/model/ModifyDBClusterConfigResult.cc
+	src/model/ModifyDBInstanceAttributeRequest.cc
+	src/model/ModifyDBInstanceAttributeResult.cc
+	src/model/ModifyElasticRuleRequest.cc
+	src/model/ModifyElasticRuleResult.cc
+	src/model/ModifySecurityIPListRequest.cc
+	src/model/ModifySecurityIPListResult.cc
+	src/model/ReleaseInstancePublicConnectionRequest.cc
+	src/model/ReleaseInstancePublicConnectionResult.cc
+	src/model/ResetAccountPasswordRequest.cc
+	src/model/ResetAccountPasswordResult.cc
+	src/model/RestartDBClusterRequest.cc
+	src/model/RestartDBClusterResult.cc
+	src/model/StartBEClusterRequest.cc
+	src/model/StartBEClusterResult.cc
+	src/model/StopBEClusterRequest.cc
+	src/model/StopBEClusterResult.cc
+	src/model/UpgradeDBInstanceEngineVersionRequest.cc
+	src/model/UpgradeDBInstanceEngineVersionResult.cc )
+
+add_library(selectdb ${LIB_TYPE}
+	${selectdb_public_header}
+	${selectdb_public_header_model}
+	${selectdb_src})
+
+set_target_properties(selectdb
+	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}selectdb
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(selectdb
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_SELECTDB_LIBRARY)
+endif()
+
+target_include_directories(selectdb
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(selectdb
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(selectdb
+		jsoncpp)
+	target_include_directories(selectdb
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(selectdb
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(selectdb
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(selectdb
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(selectdb
+		jsoncpp)
+endif()
+
+install(FILES ${selectdb_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/selectdb)
+install(FILES ${selectdb_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/selectdb/model)
+install(TARGETS selectdb
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

selectdb/include/alibabacloud/selectdb/SelectdbClient.h

@@ -0,0 +1,310 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SELECTDB_SELECTDBCLIENT_H_
+#define ALIBABACLOUD_SELECTDB_SELECTDBCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "SelectdbExport.h"
+#include "model/AllocateInstancePublicConnectionRequest.h"
+#include "model/AllocateInstancePublicConnectionResult.h"
+#include "model/CheckCreateDBInstanceRequest.h"
+#include "model/CheckCreateDBInstanceResult.h"
+#include "model/CheckServiceLinkedRoleRequest.h"
+#include "model/CheckServiceLinkedRoleResult.h"
+#include "model/CreateDBClusterRequest.h"
+#include "model/CreateDBClusterResult.h"
+#include "model/CreateDBInstanceRequest.h"
+#include "model/CreateDBInstanceResult.h"
+#include "model/CreateElasticRuleRequest.h"
+#include "model/CreateElasticRuleResult.h"
+#include "model/CreateServiceLinkedRoleForSelectDBRequest.h"
+#include "model/CreateServiceLinkedRoleForSelectDBResult.h"
+#include "model/DeleteDBClusterRequest.h"
+#include "model/DeleteDBClusterResult.h"
+#include "model/DeleteDBInstanceRequest.h"
+#include "model/DeleteDBInstanceResult.h"
+#include "model/DeleteElasticRuleRequest.h"
+#include "model/DeleteElasticRuleResult.h"
+#include "model/DescribeAllDBInstanceClassRequest.h"
+#include "model/DescribeAllDBInstanceClassResult.h"
+#include "model/DescribeDBClusterConfigRequest.h"
+#include "model/DescribeDBClusterConfigResult.h"
+#include "model/DescribeDBClusterConfigChangeLogsRequest.h"
+#include "model/DescribeDBClusterConfigChangeLogsResult.h"
+#include "model/DescribeDBInstanceAttributeRequest.h"
+#include "model/DescribeDBInstanceAttributeResult.h"
+#include "model/DescribeDBInstanceNetInfoRequest.h"
+#include "model/DescribeDBInstanceNetInfoResult.h"
+#include "model/DescribeDBInstancesRequest.h"
+#include "model/DescribeDBInstancesResult.h"
+#include "model/DescribeElasticRulesRequest.h"
+#include "model/DescribeElasticRulesResult.h"
+#include "model/DescribeSecurityIPListRequest.h"
+#include "model/DescribeSecurityIPListResult.h"
+#include "model/EnDisableScalingRulesRequest.h"
+#include "model/EnDisableScalingRulesResult.h"
+#include "model/GetCreateBEClusterInquiryRequest.h"
+#include "model/GetCreateBEClusterInquiryResult.h"
+#include "model/GetModifyBEClusterInquiryRequest.h"
+#include "model/GetModifyBEClusterInquiryResult.h"
+#include "model/ModifyBEClusterAttributeRequest.h"
+#include "model/ModifyBEClusterAttributeResult.h"
+#include "model/ModifyDBClusterRequest.h"
+#include "model/ModifyDBClusterResult.h"
+#include "model/ModifyDBClusterConfigRequest.h"
+#include "model/ModifyDBClusterConfigResult.h"
+#include "model/ModifyDBInstanceAttributeRequest.h"
+#include "model/ModifyDBInstanceAttributeResult.h"
+#include "model/ModifyElasticRuleRequest.h"
+#include "model/ModifyElasticRuleResult.h"
+#include "model/ModifySecurityIPListRequest.h"
+#include "model/ModifySecurityIPListResult.h"
+#include "model/ReleaseInstancePublicConnectionRequest.h"
+#include "model/ReleaseInstancePublicConnectionResult.h"
+#include "model/ResetAccountPasswordRequest.h"
+#include "model/ResetAccountPasswordResult.h"
+#include "model/RestartDBClusterRequest.h"
+#include "model/RestartDBClusterResult.h"
+#include "model/StartBEClusterRequest.h"
+#include "model/StartBEClusterResult.h"
+#include "model/StopBEClusterRequest.h"
+#include "model/StopBEClusterResult.h"
+#include "model/UpgradeDBInstanceEngineVersionRequest.h"
+#include "model/UpgradeDBInstanceEngineVersionResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		class ALIBABACLOUD_SELECTDB_EXPORT SelectdbClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AllocateInstancePublicConnectionResult> AllocateInstancePublicConnectionOutcome;
+			typedef std::future<AllocateInstancePublicConnectionOutcome> AllocateInstancePublicConnectionOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::AllocateInstancePublicConnectionRequest&, const AllocateInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateInstancePublicConnectionAsyncHandler;
+			typedef Outcome<Error, Model::CheckCreateDBInstanceResult> CheckCreateDBInstanceOutcome;
+			typedef std::future<CheckCreateDBInstanceOutcome> CheckCreateDBInstanceOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::CheckCreateDBInstanceRequest&, const CheckCreateDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckCreateDBInstanceAsyncHandler;
+			typedef Outcome<Error, Model::CheckServiceLinkedRoleResult> CheckServiceLinkedRoleOutcome;
+			typedef std::future<CheckServiceLinkedRoleOutcome> CheckServiceLinkedRoleOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::CheckServiceLinkedRoleRequest&, const CheckServiceLinkedRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckServiceLinkedRoleAsyncHandler;
+			typedef Outcome<Error, Model::CreateDBClusterResult> CreateDBClusterOutcome;
+			typedef std::future<CreateDBClusterOutcome> CreateDBClusterOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::CreateDBClusterRequest&, const CreateDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBClusterAsyncHandler;
+			typedef Outcome<Error, Model::CreateDBInstanceResult> CreateDBInstanceOutcome;
+			typedef std::future<CreateDBInstanceOutcome> CreateDBInstanceOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::CreateDBInstanceRequest&, const CreateDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBInstanceAsyncHandler;
+			typedef Outcome<Error, Model::CreateElasticRuleResult> CreateElasticRuleOutcome;
+			typedef std::future<CreateElasticRuleOutcome> CreateElasticRuleOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::CreateElasticRuleRequest&, const CreateElasticRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateElasticRuleAsyncHandler;
+			typedef Outcome<Error, Model::CreateServiceLinkedRoleForSelectDBResult> CreateServiceLinkedRoleForSelectDBOutcome;
+			typedef std::future<CreateServiceLinkedRoleForSelectDBOutcome> CreateServiceLinkedRoleForSelectDBOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::CreateServiceLinkedRoleForSelectDBRequest&, const CreateServiceLinkedRoleForSelectDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServiceLinkedRoleForSelectDBAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDBClusterResult> DeleteDBClusterOutcome;
+			typedef std::future<DeleteDBClusterOutcome> DeleteDBClusterOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DeleteDBClusterRequest&, const DeleteDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDBClusterAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDBInstanceResult> DeleteDBInstanceOutcome;
+			typedef std::future<DeleteDBInstanceOutcome> DeleteDBInstanceOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DeleteDBInstanceRequest&, const DeleteDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDBInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteElasticRuleResult> DeleteElasticRuleOutcome;
+			typedef std::future<DeleteElasticRuleOutcome> DeleteElasticRuleOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DeleteElasticRuleRequest&, const DeleteElasticRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteElasticRuleAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAllDBInstanceClassResult> DescribeAllDBInstanceClassOutcome;
+			typedef std::future<DescribeAllDBInstanceClassOutcome> DescribeAllDBInstanceClassOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DescribeAllDBInstanceClassRequest&, const DescribeAllDBInstanceClassOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAllDBInstanceClassAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClusterConfigResult> DescribeDBClusterConfigOutcome;
+			typedef std::future<DescribeDBClusterConfigOutcome> DescribeDBClusterConfigOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DescribeDBClusterConfigRequest&, const DescribeDBClusterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClusterConfigChangeLogsResult> DescribeDBClusterConfigChangeLogsOutcome;
+			typedef std::future<DescribeDBClusterConfigChangeLogsOutcome> DescribeDBClusterConfigChangeLogsOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DescribeDBClusterConfigChangeLogsRequest&, const DescribeDBClusterConfigChangeLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterConfigChangeLogsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBInstanceAttributeResult> DescribeDBInstanceAttributeOutcome;
+			typedef std::future<DescribeDBInstanceAttributeOutcome> DescribeDBInstanceAttributeOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DescribeDBInstanceAttributeRequest&, const DescribeDBInstanceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceAttributeAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBInstanceNetInfoResult> DescribeDBInstanceNetInfoOutcome;
+			typedef std::future<DescribeDBInstanceNetInfoOutcome> DescribeDBInstanceNetInfoOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DescribeDBInstanceNetInfoRequest&, const DescribeDBInstanceNetInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceNetInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBInstancesResult> DescribeDBInstancesOutcome;
+			typedef std::future<DescribeDBInstancesOutcome> DescribeDBInstancesOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DescribeDBInstancesRequest&, const DescribeDBInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstancesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeElasticRulesResult> DescribeElasticRulesOutcome;
+			typedef std::future<DescribeElasticRulesOutcome> DescribeElasticRulesOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DescribeElasticRulesRequest&, const DescribeElasticRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeElasticRulesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSecurityIPListResult> DescribeSecurityIPListOutcome;
+			typedef std::future<DescribeSecurityIPListOutcome> DescribeSecurityIPListOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::DescribeSecurityIPListRequest&, const DescribeSecurityIPListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecurityIPListAsyncHandler;
+			typedef Outcome<Error, Model::EnDisableScalingRulesResult> EnDisableScalingRulesOutcome;
+			typedef std::future<EnDisableScalingRulesOutcome> EnDisableScalingRulesOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::EnDisableScalingRulesRequest&, const EnDisableScalingRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnDisableScalingRulesAsyncHandler;
+			typedef Outcome<Error, Model::GetCreateBEClusterInquiryResult> GetCreateBEClusterInquiryOutcome;
+			typedef std::future<GetCreateBEClusterInquiryOutcome> GetCreateBEClusterInquiryOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::GetCreateBEClusterInquiryRequest&, const GetCreateBEClusterInquiryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCreateBEClusterInquiryAsyncHandler;
+			typedef Outcome<Error, Model::GetModifyBEClusterInquiryResult> GetModifyBEClusterInquiryOutcome;
+			typedef std::future<GetModifyBEClusterInquiryOutcome> GetModifyBEClusterInquiryOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::GetModifyBEClusterInquiryRequest&, const GetModifyBEClusterInquiryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetModifyBEClusterInquiryAsyncHandler;
+			typedef Outcome<Error, Model::ModifyBEClusterAttributeResult> ModifyBEClusterAttributeOutcome;
+			typedef std::future<ModifyBEClusterAttributeOutcome> ModifyBEClusterAttributeOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::ModifyBEClusterAttributeRequest&, const ModifyBEClusterAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBEClusterAttributeAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBClusterResult> ModifyDBClusterOutcome;
+			typedef std::future<ModifyDBClusterOutcome> ModifyDBClusterOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::ModifyDBClusterRequest&, const ModifyDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBClusterConfigResult> ModifyDBClusterConfigOutcome;
+			typedef std::future<ModifyDBClusterConfigOutcome> ModifyDBClusterConfigOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::ModifyDBClusterConfigRequest&, const ModifyDBClusterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterConfigAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDBInstanceAttributeResult> ModifyDBInstanceAttributeOutcome;
+			typedef std::future<ModifyDBInstanceAttributeOutcome> ModifyDBInstanceAttributeOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::ModifyDBInstanceAttributeRequest&, const ModifyDBInstanceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBInstanceAttributeAsyncHandler;
+			typedef Outcome<Error, Model::ModifyElasticRuleResult> ModifyElasticRuleOutcome;
+			typedef std::future<ModifyElasticRuleOutcome> ModifyElasticRuleOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::ModifyElasticRuleRequest&, const ModifyElasticRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyElasticRuleAsyncHandler;
+			typedef Outcome<Error, Model::ModifySecurityIPListResult> ModifySecurityIPListOutcome;
+			typedef std::future<ModifySecurityIPListOutcome> ModifySecurityIPListOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::ModifySecurityIPListRequest&, const ModifySecurityIPListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifySecurityIPListAsyncHandler;
+			typedef Outcome<Error, Model::ReleaseInstancePublicConnectionResult> ReleaseInstancePublicConnectionOutcome;
+			typedef std::future<ReleaseInstancePublicConnectionOutcome> ReleaseInstancePublicConnectionOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::ReleaseInstancePublicConnectionRequest&, const ReleaseInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseInstancePublicConnectionAsyncHandler;
+			typedef Outcome<Error, Model::ResetAccountPasswordResult> ResetAccountPasswordOutcome;
+			typedef std::future<ResetAccountPasswordOutcome> ResetAccountPasswordOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::ResetAccountPasswordRequest&, const ResetAccountPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetAccountPasswordAsyncHandler;
+			typedef Outcome<Error, Model::RestartDBClusterResult> RestartDBClusterOutcome;
+			typedef std::future<RestartDBClusterOutcome> RestartDBClusterOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::RestartDBClusterRequest&, const RestartDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartDBClusterAsyncHandler;
+			typedef Outcome<Error, Model::StartBEClusterResult> StartBEClusterOutcome;
+			typedef std::future<StartBEClusterOutcome> StartBEClusterOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::StartBEClusterRequest&, const StartBEClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartBEClusterAsyncHandler;
+			typedef Outcome<Error, Model::StopBEClusterResult> StopBEClusterOutcome;
+			typedef std::future<StopBEClusterOutcome> StopBEClusterOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::StopBEClusterRequest&, const StopBEClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopBEClusterAsyncHandler;
+			typedef Outcome<Error, Model::UpgradeDBInstanceEngineVersionResult> UpgradeDBInstanceEngineVersionOutcome;
+			typedef std::future<UpgradeDBInstanceEngineVersionOutcome> UpgradeDBInstanceEngineVersionOutcomeCallable;
+			typedef std::function<void(const SelectdbClient*, const Model::UpgradeDBInstanceEngineVersionRequest&, const UpgradeDBInstanceEngineVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeDBInstanceEngineVersionAsyncHandler;
+
+			SelectdbClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			SelectdbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			SelectdbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~SelectdbClient();
+			AllocateInstancePublicConnectionOutcome allocateInstancePublicConnection(const Model::AllocateInstancePublicConnectionRequest &request)const;
+			void allocateInstancePublicConnectionAsync(const Model::AllocateInstancePublicConnectionRequest& request, const AllocateInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AllocateInstancePublicConnectionOutcomeCallable allocateInstancePublicConnectionCallable(const Model::AllocateInstancePublicConnectionRequest& request) const;
+			CheckCreateDBInstanceOutcome checkCreateDBInstance(const Model::CheckCreateDBInstanceRequest &request)const;
+			void checkCreateDBInstanceAsync(const Model::CheckCreateDBInstanceRequest& request, const CheckCreateDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckCreateDBInstanceOutcomeCallable checkCreateDBInstanceCallable(const Model::CheckCreateDBInstanceRequest& 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;
+			CreateDBClusterOutcome createDBCluster(const Model::CreateDBClusterRequest &request)const;
+			void createDBClusterAsync(const Model::CreateDBClusterRequest& request, const CreateDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDBClusterOutcomeCallable createDBClusterCallable(const Model::CreateDBClusterRequest& 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;
+			CreateElasticRuleOutcome createElasticRule(const Model::CreateElasticRuleRequest &request)const;
+			void createElasticRuleAsync(const Model::CreateElasticRuleRequest& request, const CreateElasticRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateElasticRuleOutcomeCallable createElasticRuleCallable(const Model::CreateElasticRuleRequest& request) const;
+			CreateServiceLinkedRoleForSelectDBOutcome createServiceLinkedRoleForSelectDB(const Model::CreateServiceLinkedRoleForSelectDBRequest &request)const;
+			void createServiceLinkedRoleForSelectDBAsync(const Model::CreateServiceLinkedRoleForSelectDBRequest& request, const CreateServiceLinkedRoleForSelectDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateServiceLinkedRoleForSelectDBOutcomeCallable createServiceLinkedRoleForSelectDBCallable(const Model::CreateServiceLinkedRoleForSelectDBRequest& 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;
+			DeleteDBInstanceOutcome deleteDBInstance(const Model::DeleteDBInstanceRequest &request)const;
+			void deleteDBInstanceAsync(const Model::DeleteDBInstanceRequest& request, const DeleteDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteDBInstanceOutcomeCallable deleteDBInstanceCallable(const Model::DeleteDBInstanceRequest& request) const;
+			DeleteElasticRuleOutcome deleteElasticRule(const Model::DeleteElasticRuleRequest &request)const;
+			void deleteElasticRuleAsync(const Model::DeleteElasticRuleRequest& request, const DeleteElasticRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteElasticRuleOutcomeCallable deleteElasticRuleCallable(const Model::DeleteElasticRuleRequest& request) const;
+			DescribeAllDBInstanceClassOutcome describeAllDBInstanceClass(const Model::DescribeAllDBInstanceClassRequest &request)const;
+			void describeAllDBInstanceClassAsync(const Model::DescribeAllDBInstanceClassRequest& request, const DescribeAllDBInstanceClassAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAllDBInstanceClassOutcomeCallable describeAllDBInstanceClassCallable(const Model::DescribeAllDBInstanceClassRequest& 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;
+			DescribeDBClusterConfigChangeLogsOutcome describeDBClusterConfigChangeLogs(const Model::DescribeDBClusterConfigChangeLogsRequest &request)const;
+			void describeDBClusterConfigChangeLogsAsync(const Model::DescribeDBClusterConfigChangeLogsRequest& request, const DescribeDBClusterConfigChangeLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClusterConfigChangeLogsOutcomeCallable describeDBClusterConfigChangeLogsCallable(const Model::DescribeDBClusterConfigChangeLogsRequest& request) const;
+			DescribeDBInstanceAttributeOutcome describeDBInstanceAttribute(const Model::DescribeDBInstanceAttributeRequest &request)const;
+			void describeDBInstanceAttributeAsync(const Model::DescribeDBInstanceAttributeRequest& request, const DescribeDBInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBInstanceAttributeOutcomeCallable describeDBInstanceAttributeCallable(const Model::DescribeDBInstanceAttributeRequest& request) const;
+			DescribeDBInstanceNetInfoOutcome describeDBInstanceNetInfo(const Model::DescribeDBInstanceNetInfoRequest &request)const;
+			void describeDBInstanceNetInfoAsync(const Model::DescribeDBInstanceNetInfoRequest& request, const DescribeDBInstanceNetInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBInstanceNetInfoOutcomeCallable describeDBInstanceNetInfoCallable(const Model::DescribeDBInstanceNetInfoRequest& request) const;
+			DescribeDBInstancesOutcome describeDBInstances(const Model::DescribeDBInstancesRequest &request)const;
+			void describeDBInstancesAsync(const Model::DescribeDBInstancesRequest& request, const DescribeDBInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBInstancesOutcomeCallable describeDBInstancesCallable(const Model::DescribeDBInstancesRequest& request) const;
+			DescribeElasticRulesOutcome describeElasticRules(const Model::DescribeElasticRulesRequest &request)const;
+			void describeElasticRulesAsync(const Model::DescribeElasticRulesRequest& request, const DescribeElasticRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeElasticRulesOutcomeCallable describeElasticRulesCallable(const Model::DescribeElasticRulesRequest& request) const;
+			DescribeSecurityIPListOutcome describeSecurityIPList(const Model::DescribeSecurityIPListRequest &request)const;
+			void describeSecurityIPListAsync(const Model::DescribeSecurityIPListRequest& request, const DescribeSecurityIPListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSecurityIPListOutcomeCallable describeSecurityIPListCallable(const Model::DescribeSecurityIPListRequest& request) const;
+			EnDisableScalingRulesOutcome enDisableScalingRules(const Model::EnDisableScalingRulesRequest &request)const;
+			void enDisableScalingRulesAsync(const Model::EnDisableScalingRulesRequest& request, const EnDisableScalingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnDisableScalingRulesOutcomeCallable enDisableScalingRulesCallable(const Model::EnDisableScalingRulesRequest& request) const;
+			GetCreateBEClusterInquiryOutcome getCreateBEClusterInquiry(const Model::GetCreateBEClusterInquiryRequest &request)const;
+			void getCreateBEClusterInquiryAsync(const Model::GetCreateBEClusterInquiryRequest& request, const GetCreateBEClusterInquiryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCreateBEClusterInquiryOutcomeCallable getCreateBEClusterInquiryCallable(const Model::GetCreateBEClusterInquiryRequest& request) const;
+			GetModifyBEClusterInquiryOutcome getModifyBEClusterInquiry(const Model::GetModifyBEClusterInquiryRequest &request)const;
+			void getModifyBEClusterInquiryAsync(const Model::GetModifyBEClusterInquiryRequest& request, const GetModifyBEClusterInquiryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetModifyBEClusterInquiryOutcomeCallable getModifyBEClusterInquiryCallable(const Model::GetModifyBEClusterInquiryRequest& request) const;
+			ModifyBEClusterAttributeOutcome modifyBEClusterAttribute(const Model::ModifyBEClusterAttributeRequest &request)const;
+			void modifyBEClusterAttributeAsync(const Model::ModifyBEClusterAttributeRequest& request, const ModifyBEClusterAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyBEClusterAttributeOutcomeCallable modifyBEClusterAttributeCallable(const Model::ModifyBEClusterAttributeRequest& 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;
+			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;
+			ModifyDBInstanceAttributeOutcome modifyDBInstanceAttribute(const Model::ModifyDBInstanceAttributeRequest &request)const;
+			void modifyDBInstanceAttributeAsync(const Model::ModifyDBInstanceAttributeRequest& request, const ModifyDBInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDBInstanceAttributeOutcomeCallable modifyDBInstanceAttributeCallable(const Model::ModifyDBInstanceAttributeRequest& request) const;
+			ModifyElasticRuleOutcome modifyElasticRule(const Model::ModifyElasticRuleRequest &request)const;
+			void modifyElasticRuleAsync(const Model::ModifyElasticRuleRequest& request, const ModifyElasticRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyElasticRuleOutcomeCallable modifyElasticRuleCallable(const Model::ModifyElasticRuleRequest& request) const;
+			ModifySecurityIPListOutcome modifySecurityIPList(const Model::ModifySecurityIPListRequest &request)const;
+			void modifySecurityIPListAsync(const Model::ModifySecurityIPListRequest& request, const ModifySecurityIPListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifySecurityIPListOutcomeCallable modifySecurityIPListCallable(const Model::ModifySecurityIPListRequest& request) const;
+			ReleaseInstancePublicConnectionOutcome releaseInstancePublicConnection(const Model::ReleaseInstancePublicConnectionRequest &request)const;
+			void releaseInstancePublicConnectionAsync(const Model::ReleaseInstancePublicConnectionRequest& request, const ReleaseInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReleaseInstancePublicConnectionOutcomeCallable releaseInstancePublicConnectionCallable(const Model::ReleaseInstancePublicConnectionRequest& 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;
+			RestartDBClusterOutcome restartDBCluster(const Model::RestartDBClusterRequest &request)const;
+			void restartDBClusterAsync(const Model::RestartDBClusterRequest& request, const RestartDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RestartDBClusterOutcomeCallable restartDBClusterCallable(const Model::RestartDBClusterRequest& request) const;
+			StartBEClusterOutcome startBECluster(const Model::StartBEClusterRequest &request)const;
+			void startBEClusterAsync(const Model::StartBEClusterRequest& request, const StartBEClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartBEClusterOutcomeCallable startBEClusterCallable(const Model::StartBEClusterRequest& request) const;
+			StopBEClusterOutcome stopBECluster(const Model::StopBEClusterRequest &request)const;
+			void stopBEClusterAsync(const Model::StopBEClusterRequest& request, const StopBEClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopBEClusterOutcomeCallable stopBEClusterCallable(const Model::StopBEClusterRequest& request) const;
+			UpgradeDBInstanceEngineVersionOutcome upgradeDBInstanceEngineVersion(const Model::UpgradeDBInstanceEngineVersionRequest &request)const;
+			void upgradeDBInstanceEngineVersionAsync(const Model::UpgradeDBInstanceEngineVersionRequest& request, const UpgradeDBInstanceEngineVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpgradeDBInstanceEngineVersionOutcomeCallable upgradeDBInstanceEngineVersionCallable(const Model::UpgradeDBInstanceEngineVersionRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_SELECTDB_SELECTDBCLIENT_H_

selectdb/include/alibabacloud/selectdb/SelectdbExport.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_SELECTDB_SELECTDBEXPORT_H_
+#define ALIBABACLOUD_SELECTDB_SELECTDBEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_SELECTDB_LIBRARY)
+#		define ALIBABACLOUD_SELECTDB_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_SELECTDB_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_SELECTDB_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_SELECTDB_SELECTDBEXPORT_H_

selectdb/include/alibabacloud/selectdb/model/AllocateInstancePublicConnectionRequest.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_SELECTDB_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT AllocateInstancePublicConnectionRequest : public RpcServiceRequest {
+public:
+	AllocateInstancePublicConnectionRequest();
+	~AllocateInstancePublicConnectionRequest();
+	std::string getConnectionStringPrefix() const;
+	void setConnectionStringPrefix(const std::string &connectionStringPrefix);
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNetType() const;
+	void setNetType(const std::string &netType);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	std::string connectionStringPrefix_;
+	long resourceOwnerId_;
+	std::string regionId_;
+	std::string netType_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/AllocateInstancePublicConnectionResult.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_SELECTDB_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT AllocateInstancePublicConnectionResult : public ServiceResult
+			{
+			public:
+
+
+				AllocateInstancePublicConnectionResult();
+				explicit AllocateInstancePublicConnectionResult(const std::string &payload);
+				~AllocateInstancePublicConnectionResult();
+				std::string getInstanceName()const;
+				long getTaskId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string instanceName_;
+				long taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONRESULT_H_

selectdb/include/alibabacloud/selectdb/model/CheckCreateDBInstanceRequest.h

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SELECTDB_MODEL_CHECKCREATEDBINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CHECKCREATEDBINSTANCEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT CheckCreateDBInstanceRequest : public RpcServiceRequest {
+public:
+	CheckCreateDBInstanceRequest();
+	~CheckCreateDBInstanceRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getConnectionString() const;
+	void setConnectionString(const std::string &connectionString);
+	std::string getEngineVersion() const;
+	void setEngineVersion(const std::string &engineVersion);
+	int getCacheSize() const;
+	void setCacheSize(int cacheSize);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getEngine() const;
+	void setEngine(const std::string &engine);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceDescription() const;
+	void setDBInstanceDescription(const std::string &dBInstanceDescription);
+	std::string getPeriod() const;
+	void setPeriod(const std::string &period);
+	int getUsedTime() const;
+	void setUsedTime(int usedTime);
+	std::string getDBInstanceClass() const;
+	void setDBInstanceClass(const std::string &dBInstanceClass);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getSecurityIPList() const;
+	void setSecurityIPList(const std::string &securityIPList);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
+
+private:
+	long resourceOwnerId_;
+	std::string clientToken_;
+	std::string connectionString_;
+	std::string engineVersion_;
+	int cacheSize_;
+	std::string resourceGroupId_;
+	std::string engine_;
+	std::string regionId_;
+	std::string dBInstanceDescription_;
+	std::string period_;
+	int usedTime_;
+	std::string dBInstanceClass_;
+	std::string vSwitchId_;
+	std::string securityIPList_;
+	std::string vpcId_;
+	std::string zoneId_;
+	std::string chargeType_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CHECKCREATEDBINSTANCEREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/CheckCreateDBInstanceResult.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_SELECTDB_MODEL_CHECKCREATEDBINSTANCERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CHECKCREATEDBINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT CheckCreateDBInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				CheckCreateDBInstanceResult();
+				explicit CheckCreateDBInstanceResult(const std::string &payload);
+				~CheckCreateDBInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CHECKCREATEDBINSTANCERESULT_H_

selectdb/include/alibabacloud/selectdb/model/CheckServiceLinkedRoleRequest.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_SELECTDB_MODEL_CHECKSERVICELINKEDROLEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CHECKSERVICELINKEDROLEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT CheckServiceLinkedRoleRequest : public RpcServiceRequest {
+public:
+	CheckServiceLinkedRoleRequest();
+	~CheckServiceLinkedRoleRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+
+private:
+	long resourceOwnerId_;
+	std::string ownerAccount_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CHECKSERVICELINKEDROLEREQUEST_H_

selectdb/include/alibabacloud/selectdb/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_SELECTDB_MODEL_CHECKSERVICELINKEDROLERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CHECKSERVICELINKEDROLERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_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_SELECTDB_MODEL_CHECKSERVICELINKEDROLERESULT_H_

selectdb/include/alibabacloud/selectdb/model/CreateDBClusterRequest.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_SELECTDB_MODEL_CREATEDBCLUSTERREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CREATEDBCLUSTERREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT CreateDBClusterRequest : public RpcServiceRequest {
+public:
+	CreateDBClusterRequest();
+	~CreateDBClusterRequest();
+	std::string getDBClusterDescription() const;
+	void setDBClusterDescription(const std::string &dBClusterDescription);
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getEngineVersion() const;
+	void setEngineVersion(const std::string &engineVersion);
+	std::string getCacheSize() const;
+	void setCacheSize(const std::string &cacheSize);
+	std::string getEngine() const;
+	void setEngine(const std::string &engine);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+	std::string getPeriod() const;
+	void setPeriod(const std::string &period);
+	std::string getDBClusterClass() const;
+	void setDBClusterClass(const std::string &dBClusterClass);
+	std::string getUsedTime() const;
+	void setUsedTime(const std::string &usedTime);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
+
+private:
+	std::string dBClusterDescription_;
+	long resourceOwnerId_;
+	std::string engineVersion_;
+	std::string cacheSize_;
+	std::string engine_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+	std::string period_;
+	std::string dBClusterClass_;
+	std::string usedTime_;
+	std::string vSwitchId_;
+	std::string vpcId_;
+	std::string zoneId_;
+	std::string chargeType_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CREATEDBCLUSTERREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/CreateDBClusterResult.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_SELECTDB_MODEL_CREATEDBCLUSTERRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CREATEDBCLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT CreateDBClusterResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string dBInstanceId;
+					std::string clusterId;
+					long orderId;
+				};
+
+
+				CreateDBClusterResult();
+				explicit CreateDBClusterResult(const std::string &payload);
+				~CreateDBClusterResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CREATEDBCLUSTERRESULT_H_

selectdb/include/alibabacloud/selectdb/model/CreateDBInstanceRequest.h

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SELECTDB_MODEL_CREATEDBINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CREATEDBINSTANCEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT CreateDBInstanceRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	CreateDBInstanceRequest();
+	~CreateDBInstanceRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getConnectionString() const;
+	void setConnectionString(const std::string &connectionString);
+	std::string getEngineVersion() const;
+	void setEngineVersion(const std::string &engineVersion);
+	int getCacheSize() const;
+	void setCacheSize(int cacheSize);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getEngine() const;
+	void setEngine(const std::string &engine);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceDescription() const;
+	void setDBInstanceDescription(const std::string &dBInstanceDescription);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::string getPeriod() const;
+	void setPeriod(const std::string &period);
+	int getUsedTime() const;
+	void setUsedTime(int usedTime);
+	std::string getDBInstanceClass() const;
+	void setDBInstanceClass(const std::string &dBInstanceClass);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getSecurityIPList() const;
+	void setSecurityIPList(const std::string &securityIPList);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
+
+private:
+	long resourceOwnerId_;
+	std::string clientToken_;
+	std::string connectionString_;
+	std::string engineVersion_;
+	int cacheSize_;
+	std::string resourceGroupId_;
+	std::string engine_;
+	std::string regionId_;
+	std::string dBInstanceDescription_;
+	std::vector<Tag> tag_;
+	std::string period_;
+	int usedTime_;
+	std::string dBInstanceClass_;
+	std::string vSwitchId_;
+	std::string securityIPList_;
+	std::string vpcId_;
+	std::string zoneId_;
+	std::string chargeType_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CREATEDBINSTANCEREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/CreateDBInstanceResult.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_SELECTDB_MODEL_CREATEDBINSTANCERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CREATEDBINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT CreateDBInstanceResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string dBInstanceId;
+					long orderId;
+				};
+
+
+				CreateDBInstanceResult();
+				explicit CreateDBInstanceResult(const std::string &payload);
+				~CreateDBInstanceResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CREATEDBINSTANCERESULT_H_

selectdb/include/alibabacloud/selectdb/model/CreateElasticRuleRequest.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_SELECTDB_MODEL_CREATEELASTICRULEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CREATEELASTICRULEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT CreateElasticRuleRequest : public RpcServiceRequest {
+public:
+	CreateElasticRuleRequest();
+	~CreateElasticRuleRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getExecutionPeriod() const;
+	void setExecutionPeriod(const std::string &executionPeriod);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getElasticRuleStartTime() const;
+	void setElasticRuleStartTime(const std::string &elasticRuleStartTime);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getClusterClass() const;
+	void setClusterClass(const std::string &clusterClass);
+	std::string getDbInstanceId() const;
+	void setDbInstanceId(const std::string &dbInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string executionPeriod_;
+	std::string clusterId_;
+	std::string elasticRuleStartTime_;
+	std::string regionId_;
+	std::string clusterClass_;
+	std::string dbInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CREATEELASTICRULEREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/CreateElasticRuleResult.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_SELECTDB_MODEL_CREATEELASTICRULERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CREATEELASTICRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT CreateElasticRuleResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string clusterId;
+					long ruleId;
+					std::string elasticRuleStartTime;
+					std::string dbInstanceId;
+					std::string executionPeriod;
+					std::string clusterClass;
+				};
+
+
+				CreateElasticRuleResult();
+				explicit CreateElasticRuleResult(const std::string &payload);
+				~CreateElasticRuleResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CREATEELASTICRULERESULT_H_

selectdb/include/alibabacloud/selectdb/model/CreateServiceLinkedRoleForSelectDBRequest.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_SELECTDB_MODEL_CREATESERVICELINKEDROLEFORSELECTDBREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CREATESERVICELINKEDROLEFORSELECTDBREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT CreateServiceLinkedRoleForSelectDBRequest : public RpcServiceRequest {
+public:
+	CreateServiceLinkedRoleForSelectDBRequest();
+	~CreateServiceLinkedRoleForSelectDBRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+
+private:
+	long resourceOwnerId_;
+	std::string ownerAccount_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CREATESERVICELINKEDROLEFORSELECTDBREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/CreateServiceLinkedRoleForSelectDBResult.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_SELECTDB_MODEL_CREATESERVICELINKEDROLEFORSELECTDBRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_CREATESERVICELINKEDROLEFORSELECTDBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT CreateServiceLinkedRoleForSelectDBResult : public ServiceResult
+			{
+			public:
+
+
+				CreateServiceLinkedRoleForSelectDBResult();
+				explicit CreateServiceLinkedRoleForSelectDBResult(const std::string &payload);
+				~CreateServiceLinkedRoleForSelectDBResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_CREATESERVICELINKEDROLEFORSELECTDBRESULT_H_

selectdb/include/alibabacloud/selectdb/model/DeleteDBClusterRequest.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_SELECTDB_MODEL_DELETEDBCLUSTERREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DELETEDBCLUSTERREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DeleteDBClusterRequest : public RpcServiceRequest {
+public:
+	DeleteDBClusterRequest();
+	~DeleteDBClusterRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string dBClusterId_;
+	std::string resourceGroupId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DELETEDBCLUSTERREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DeleteDBClusterResult.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_SELECTDB_MODEL_DELETEDBCLUSTERRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DELETEDBCLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DeleteDBClusterResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string dBInstanceId;
+					std::string orderId;
+				};
+
+
+				DeleteDBClusterResult();
+				explicit DeleteDBClusterResult(const std::string &payload);
+				~DeleteDBClusterResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DELETEDBCLUSTERRESULT_H_

selectdb/include/alibabacloud/selectdb/model/DeleteDBInstanceRequest.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_SELECTDB_MODEL_DELETEDBINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DELETEDBINSTANCEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DeleteDBInstanceRequest : public RpcServiceRequest {
+public:
+	DeleteDBInstanceRequest();
+	~DeleteDBInstanceRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DELETEDBINSTANCEREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DeleteDBInstanceResult.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_SELECTDB_MODEL_DELETEDBINSTANCERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DELETEDBINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DeleteDBInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteDBInstanceResult();
+				explicit DeleteDBInstanceResult(const std::string &payload);
+				~DeleteDBInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DELETEDBINSTANCERESULT_H_

selectdb/include/alibabacloud/selectdb/model/DeleteElasticRuleRequest.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_SELECTDB_MODEL_DELETEELASTICRULEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DELETEELASTICRULEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DeleteElasticRuleRequest : public RpcServiceRequest {
+public:
+	DeleteElasticRuleRequest();
+	~DeleteElasticRuleRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getProduct() const;
+	void setProduct(const std::string &product);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDbInstanceId() const;
+	void setDbInstanceId(const std::string &dbInstanceId);
+	long getRuleId() const;
+	void setRuleId(long ruleId);
+
+private:
+	long resourceOwnerId_;
+	std::string product_;
+	std::string clusterId_;
+	std::string regionId_;
+	std::string dbInstanceId_;
+	long ruleId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DELETEELASTICRULEREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DeleteElasticRuleResult.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_SELECTDB_MODEL_DELETEELASTICRULERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DELETEELASTICRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DeleteElasticRuleResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteElasticRuleResult();
+				explicit DeleteElasticRuleResult(const std::string &payload);
+				~DeleteElasticRuleResult();
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DELETEELASTICRULERESULT_H_

selectdb/include/alibabacloud/selectdb/model/DescribeAllDBInstanceClassRequest.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_SELECTDB_MODEL_DESCRIBEALLDBINSTANCECLASSREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEALLDBINSTANCECLASSREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DescribeAllDBInstanceClassRequest : public RpcServiceRequest {
+public:
+	DescribeAllDBInstanceClassRequest();
+	~DescribeAllDBInstanceClassRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	long resourceOwnerId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEALLDBINSTANCECLASSREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DescribeAllDBInstanceClassResult.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_SELECTDB_MODEL_DESCRIBEALLDBINSTANCECLASSRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEALLDBINSTANCECLASSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DescribeAllDBInstanceClassResult : public ServiceResult
+			{
+			public:
+				struct ClassCodeListItem
+				{
+					long defaultStorageInGB;
+					long minStorageInGB;
+					long stepStorageInGB;
+					std::string classCode;
+					long maxStorageInGB;
+					long cpuCores;
+					long memoryInGB;
+				};
+
+
+				DescribeAllDBInstanceClassResult();
+				explicit DescribeAllDBInstanceClassResult(const std::string &payload);
+				~DescribeAllDBInstanceClassResult();
+				std::vector<ClassCodeListItem> getClassCodeList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ClassCodeListItem> classCodeList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEALLDBINSTANCECLASSRESULT_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBClusterConfigChangeLogsRequest.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_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGCHANGELOGSREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGCHANGELOGSREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBClusterConfigChangeLogsRequest : public RpcServiceRequest {
+public:
+	DescribeDBClusterConfigChangeLogsRequest();
+	~DescribeDBClusterConfigChangeLogsRequest();
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getConfigKey() const;
+	void setConfigKey(const std::string &configKey);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+	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 configKey_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+	std::string dBClusterId_;
+	std::string endTime_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGCHANGELOGSREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBClusterConfigChangeLogsResult.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_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGCHANGELOGSRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGCHANGELOGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBClusterConfigChangeLogsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ParamChangeLog
+					{
+						std::string oldValue;
+						bool isApplied;
+						std::string gmtModified;
+						std::string newValue;
+						long id;
+						std::string gmtCreated;
+						std::string name;
+					};
+					std::vector<ParamChangeLog> paramChangeLogs;
+					int taskId;
+					std::string dbClusterId;
+					std::string dbInstanceName;
+					std::string dbInstanceId;
+				};
+
+
+				DescribeDBClusterConfigChangeLogsResult();
+				explicit DescribeDBClusterConfigChangeLogsResult(const std::string &payload);
+				~DescribeDBClusterConfigChangeLogsResult();
+				std::string getAccessDeniedDetail()const;
+				Data getData()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string accessDeniedDetail_;
+				Data data_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGCHANGELOGSRESULT_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBClusterConfigRequest.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_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBClusterConfigRequest : public RpcServiceRequest {
+public:
+	DescribeDBClusterConfigRequest();
+	~DescribeDBClusterConfigRequest();
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getConfigKey() const;
+	void setConfigKey(const std::string &configKey);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	std::string dBClusterId_;
+	std::string configKey_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBClusterConfigResult.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_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBClusterConfigResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Param
+					{
+						std::string comment;
+						std::string defaultValue;
+						std::string optional;
+						std::string paramCategory;
+						std::string value;
+						int isUserModifiable;
+						int isDynamic;
+						std::string name;
+					};
+					int taskId;
+					std::vector<Param> params;
+					std::string dbClusterId;
+					std::string dbInstanceName;
+					std::string dbInstanceId;
+				};
+
+
+				DescribeDBClusterConfigResult();
+				explicit DescribeDBClusterConfigResult(const std::string &payload);
+				~DescribeDBClusterConfigResult();
+				std::string getAccessDeniedDetail()const;
+				Data getData()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string accessDeniedDetail_;
+				Data data_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBCLUSTERCONFIGRESULT_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBInstanceAttributeRequest.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_SELECTDB_MODEL_DESCRIBEDBINSTANCEATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCEATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBInstanceAttributeRequest : public RpcServiceRequest {
+public:
+	DescribeDBInstanceAttributeRequest();
+	~DescribeDBInstanceAttributeRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCEATTRIBUTEREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBInstanceAttributeResult.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCEATTRIBUTERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCEATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBInstanceAttributeResult : public ServiceResult
+			{
+			public:
+				struct DbClusterListItem
+				{
+					std::string status;
+					std::string createdTime;
+					long memory;
+					std::string performanceLevel;
+					std::string startTime;
+					std::string dbClusterName;
+					bool scalingRulesEnable;
+					std::string cacheStorageType;
+					std::string modifiedTime;
+					std::string chargeType;
+					long cpuCores;
+					std::string dbClusterId;
+					std::string cacheStorageSizeGB;
+					std::string dbInstanceName;
+					std::string dbClusterClass;
+				};
+				struct TagsItem
+				{
+					std::string tagKey;
+					std::string tagValue;
+				};
+
+
+				DescribeDBInstanceAttributeResult();
+				explicit DescribeDBInstanceAttributeResult(const std::string &payload);
+				~DescribeDBInstanceAttributeResult();
+				std::string getEngineMinorVersion()const;
+				std::string getDescription()const;
+				std::string getResourceGroupId()const;
+				std::string getGmtModified()const;
+				std::vector<std::string> getCanUpgradeVersions()const;
+				std::string getMaintainStarttime()const;
+				std::string getSubDomain()const;
+				long getObjectStoreSize()const;
+				std::string getDBInstanceId()const;
+				std::string getLockReason()const;
+				std::vector<TagsItem> getTags()const;
+				std::string getEngine()const;
+				std::string getStatus()const;
+				std::string getMaintainEndtime()const;
+				std::string getEngineVersion()const;
+				long getResourceCpu()const;
+				std::string getZoneId()const;
+				std::string getCreateTime()const;
+				long getStorageSize()const;
+				long getLockMode()const;
+				std::vector<DbClusterListItem> getDBClusterList()const;
+				std::string getVpcId()const;
+				std::string getChargeType()const;
+				std::string getRegionId()const;
+				std::string getExpireTime()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string engineMinorVersion_;
+				std::string description_;
+				std::string resourceGroupId_;
+				std::string gmtModified_;
+				std::vector<std::string> canUpgradeVersions_;
+				std::string maintainStarttime_;
+				std::string subDomain_;
+				long objectStoreSize_;
+				std::string dBInstanceId_;
+				std::string lockReason_;
+				std::vector<TagsItem> tags_;
+				std::string engine_;
+				std::string status_;
+				std::string maintainEndtime_;
+				std::string engineVersion_;
+				long resourceCpu_;
+				std::string zoneId_;
+				std::string createTime_;
+				long storageSize_;
+				long lockMode_;
+				std::vector<DbClusterListItem> dBClusterList_;
+				std::string vpcId_;
+				std::string chargeType_;
+				std::string regionId_;
+				std::string expireTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCEATTRIBUTERESULT_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBInstanceNetInfoRequest.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_SELECTDB_MODEL_DESCRIBEDBINSTANCENETINFOREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCENETINFOREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBInstanceNetInfoRequest : public RpcServiceRequest {
+public:
+	DescribeDBInstanceNetInfoRequest();
+	~DescribeDBInstanceNetInfoRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCENETINFOREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBInstanceNetInfoResult.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_SELECTDB_MODEL_DESCRIBEDBINSTANCENETINFORESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCENETINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBInstanceNetInfoResult : public ServiceResult
+			{
+			public:
+				struct DBInstanceNetInfosItem
+				{
+					struct PortListItem
+					{
+						int port;
+						std::string protocol;
+					};
+					std::string vpcId;
+					std::string clusterId;
+					std::string ip;
+					std::string vpcInstanceId;
+					bool userVisible;
+					std::string connectionString;
+					std::string netType;
+					std::string vswitchId;
+					std::vector<DBInstanceNetInfosItem::PortListItem> portList;
+				};
+				struct DBClustersNetInfosItem
+				{
+					struct PortListItem2
+					{
+						int port;
+						std::string protocol;
+					};
+					std::string vpcId;
+					std::string clusterId;
+					std::string ip;
+					std::string vpcInstanceId;
+					bool userVisible;
+					std::vector<DBClustersNetInfosItem::PortListItem2> portList1;
+					std::string connectionString;
+					std::string netType;
+					std::string vswitchId;
+				};
+
+
+				DescribeDBInstanceNetInfoResult();
+				explicit DescribeDBInstanceNetInfoResult(const std::string &payload);
+				~DescribeDBInstanceNetInfoResult();
+				std::vector<DBClustersNetInfosItem> getDBClustersNetInfos()const;
+				std::vector<DBInstanceNetInfosItem> getDBInstanceNetInfos()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DBClustersNetInfosItem> dBClustersNetInfos_;
+				std::vector<DBInstanceNetInfosItem> dBInstanceNetInfos_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCENETINFORESULT_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBInstancesRequest.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_SELECTDB_MODEL_DESCRIBEDBINSTANCESREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCESREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBInstancesRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	DescribeDBInstancesRequest();
+	~DescribeDBInstancesRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	long getPageNumber() const;
+	void setPageNumber(long pageNumber);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	std::string getDBInstanceStatus() const;
+	void setDBInstanceStatus(const std::string &dBInstanceStatus);
+	std::string getDBInstanceDescription() const;
+	void setDBInstanceDescription(const std::string &dBInstanceDescription);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::string getDBInstanceIds() const;
+	void setDBInstanceIds(const std::string &dBInstanceIds);
+
+private:
+	long resourceOwnerId_;
+	long pageNumber_;
+	std::string resourceGroupId_;
+	std::string regionId_;
+	long pageSize_;
+	std::string dBInstanceStatus_;
+	std::string dBInstanceDescription_;
+	std::vector<Tag> tag_;
+	std::string dBInstanceIds_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCESREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DescribeDBInstancesResult.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_SELECTDB_MODEL_DESCRIBEDBINSTANCESRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DescribeDBInstancesResult : public ServiceResult
+			{
+			public:
+				struct DBInstance
+				{
+					struct TagsItem
+					{
+						std::string tagKey;
+						std::string tagValue;
+					};
+					long resourceMemory;
+					std::string description;
+					std::string category;
+					std::string resourceGroupId;
+					int clusterCount;
+					std::string gmtModified;
+					std::string gmtCreated;
+					std::string maintainStarttime;
+					std::string tenantClusterId;
+					long objectStoreSize;
+					std::string dBInstanceId;
+					std::string tenantUserId;
+					std::string lockReason;
+					std::vector<DBInstance::TagsItem> tags;
+					std::string engine;
+					std::string status;
+					std::string maintainEndtime;
+					std::string instanceUsedType;
+					bool isDeleted;
+					std::string engineVersion;
+					std::string storageType;
+					std::string zoneId;
+					long resourceCpu;
+					std::string maintainEndTimeStr;
+					long scaleReplica;
+					long storageSize;
+					long scaleMax;
+					long lockMode;
+					std::string maintainStartTimeStr;
+					std::string vswitchId;
+					std::string parentInstance;
+					std::string vpcId;
+					std::string chargeType;
+					long scaleMin;
+					std::string regionId;
+					std::string connectionString;
+					std::string expireTime;
+					std::string tenantToken;
+				};
+
+
+				DescribeDBInstancesResult();
+				explicit DescribeDBInstancesResult(const std::string &payload);
+				~DescribeDBInstancesResult();
+				long getTotalRecordCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+				std::vector<DBInstance> getItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalRecordCount_;
+				long pageSize_;
+				long pageNumber_;
+				std::vector<DBInstance> items_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEDBINSTANCESRESULT_H_

selectdb/include/alibabacloud/selectdb/model/DescribeElasticRulesRequest.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_SELECTDB_MODEL_DESCRIBEELASTICRULESREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEELASTICRULESREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DescribeElasticRulesRequest : public RpcServiceRequest {
+public:
+	DescribeElasticRulesRequest();
+	~DescribeElasticRulesRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getProduct() const;
+	void setProduct(const std::string &product);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDbInstanceId() const;
+	void setDbInstanceId(const std::string &dbInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string product_;
+	std::string clusterId_;
+	std::string regionId_;
+	std::string dbInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEELASTICRULESREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DescribeElasticRulesResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SELECTDB_MODEL_DESCRIBEELASTICRULESRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEELASTICRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DescribeElasticRulesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct RulesItem
+					{
+						long ruleId;
+						std::string elasticRuleStartTime;
+						std::string executionPeriod;
+						std::string clusterClass;
+					};
+					std::string clusterId;
+					std::string dbInstanceId;
+					std::vector<RulesItem> rules;
+				};
+
+
+				DescribeElasticRulesResult();
+				explicit DescribeElasticRulesResult(const std::string &payload);
+				~DescribeElasticRulesResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBEELASTICRULESRESULT_H_

selectdb/include/alibabacloud/selectdb/model/DescribeSecurityIPListRequest.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_SELECTDB_MODEL_DESCRIBESECURITYIPLISTREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBESECURITYIPLISTREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT DescribeSecurityIPListRequest : public RpcServiceRequest {
+public:
+	DescribeSecurityIPListRequest();
+	~DescribeSecurityIPListRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBESECURITYIPLISTREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/DescribeSecurityIPListResult.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_SELECTDB_MODEL_DESCRIBESECURITYIPLISTRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_DESCRIBESECURITYIPLISTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT DescribeSecurityIPListResult : public ServiceResult
+			{
+			public:
+				struct GroupItemsItem
+				{
+					std::string groupName;
+					std::string groupTag;
+					std::string securityIPList;
+					std::string aecurityIPType;
+					std::string whitelistNetType;
+				};
+
+
+				DescribeSecurityIPListResult();
+				explicit DescribeSecurityIPListResult(const std::string &payload);
+				~DescribeSecurityIPListResult();
+				std::vector<GroupItemsItem> getGroupItems()const;
+				std::string getDBInstanceName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<GroupItemsItem> groupItems_;
+				std::string dBInstanceName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_DESCRIBESECURITYIPLISTRESULT_H_

selectdb/include/alibabacloud/selectdb/model/EnDisableScalingRulesRequest.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_SELECTDB_MODEL_ENDISABLESCALINGRULESREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_ENDISABLESCALINGRULESREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT EnDisableScalingRulesRequest : public RpcServiceRequest {
+public:
+	EnDisableScalingRulesRequest();
+	~EnDisableScalingRulesRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getProduct() const;
+	void setProduct(const std::string &product);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDbInstanceId() const;
+	void setDbInstanceId(const std::string &dbInstanceId);
+	bool getScalingRulesEnable() const;
+	void setScalingRulesEnable(bool scalingRulesEnable);
+
+private:
+	long resourceOwnerId_;
+	std::string product_;
+	std::string clusterId_;
+	std::string regionId_;
+	std::string dbInstanceId_;
+	bool scalingRulesEnable_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_ENDISABLESCALINGRULESREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/EnDisableScalingRulesResult.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_SELECTDB_MODEL_ENDISABLESCALINGRULESRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_ENDISABLESCALINGRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT EnDisableScalingRulesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string clusterId;
+					std::string dbInstanceId;
+					bool scalingRulesEnable;
+				};
+
+
+				EnDisableScalingRulesResult();
+				explicit EnDisableScalingRulesResult(const std::string &payload);
+				~EnDisableScalingRulesResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_ENDISABLESCALINGRULESRESULT_H_

selectdb/include/alibabacloud/selectdb/model/GetCreateBEClusterInquiryRequest.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_SELECTDB_MODEL_GETCREATEBECLUSTERINQUIRYREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_GETCREATEBECLUSTERINQUIRYREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT GetCreateBEClusterInquiryRequest : public RpcServiceRequest {
+public:
+	GetCreateBEClusterInquiryRequest();
+	~GetCreateBEClusterInquiryRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	long getCacheSize() const;
+	void setCacheSize(long cacheSize);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getPreCacheSize() const;
+	void setPreCacheSize(long preCacheSize);
+	long getComputeSize() const;
+	void setComputeSize(long computeSize);
+	std::string getDbInstanceId() const;
+	void setDbInstanceId(const std::string &dbInstanceId);
+	long getPreComputeSize() const;
+	void setPreComputeSize(long preComputeSize);
+	long getQuantity() const;
+	void setQuantity(long quantity);
+	std::string getCommodityCode() const;
+	void setCommodityCode(const std::string &commodityCode);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
+	std::string getPricingCycle() const;
+	void setPricingCycle(const std::string &pricingCycle);
+
+private:
+	long resourceOwnerId_;
+	long cacheSize_;
+	std::string regionId_;
+	long preCacheSize_;
+	long computeSize_;
+	std::string dbInstanceId_;
+	long preComputeSize_;
+	long quantity_;
+	std::string commodityCode_;
+	std::string chargeType_;
+	std::string pricingCycle_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_GETCREATEBECLUSTERINQUIRYREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/GetCreateBEClusterInquiryResult.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_SELECTDB_MODEL_GETCREATEBECLUSTERINQUIRYRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_GETCREATEBECLUSTERINQUIRYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT GetCreateBEClusterInquiryResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string currency;
+					std::string tradeAmount;
+				};
+
+
+				GetCreateBEClusterInquiryResult();
+				explicit GetCreateBEClusterInquiryResult(const std::string &payload);
+				~GetCreateBEClusterInquiryResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_GETCREATEBECLUSTERINQUIRYRESULT_H_

selectdb/include/alibabacloud/selectdb/model/GetModifyBEClusterInquiryRequest.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_SELECTDB_MODEL_GETMODIFYBECLUSTERINQUIRYREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_GETMODIFYBECLUSTERINQUIRYREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT GetModifyBEClusterInquiryRequest : public RpcServiceRequest {
+public:
+	GetModifyBEClusterInquiryRequest();
+	~GetModifyBEClusterInquiryRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	long getCacheSize() const;
+	void setCacheSize(long cacheSize);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getPreCacheSize() const;
+	void setPreCacheSize(long preCacheSize);
+	long getComputeSize() const;
+	void setComputeSize(long computeSize);
+	std::string getDbInstanceId() const;
+	void setDbInstanceId(const std::string &dbInstanceId);
+	long getPreComputeSize() const;
+	void setPreComputeSize(long preComputeSize);
+	long getQuantity() const;
+	void setQuantity(long quantity);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getCommodityCode() const;
+	void setCommodityCode(const std::string &commodityCode);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
+	std::string getPricingCycle() const;
+	void setPricingCycle(const std::string &pricingCycle);
+
+private:
+	long resourceOwnerId_;
+	long cacheSize_;
+	std::string regionId_;
+	long preCacheSize_;
+	long computeSize_;
+	std::string dbInstanceId_;
+	long preComputeSize_;
+	long quantity_;
+	std::string clusterId_;
+	std::string commodityCode_;
+	std::string chargeType_;
+	std::string pricingCycle_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_GETMODIFYBECLUSTERINQUIRYREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/GetModifyBEClusterInquiryResult.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_SELECTDB_MODEL_GETMODIFYBECLUSTERINQUIRYRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_GETMODIFYBECLUSTERINQUIRYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT GetModifyBEClusterInquiryResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string currency;
+					std::string tradeAmount;
+				};
+
+
+				GetModifyBEClusterInquiryResult();
+				explicit GetModifyBEClusterInquiryResult(const std::string &payload);
+				~GetModifyBEClusterInquiryResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_GETMODIFYBECLUSTERINQUIRYRESULT_H_

selectdb/include/alibabacloud/selectdb/model/ModifyBEClusterAttributeRequest.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_SELECTDB_MODEL_MODIFYBECLUSTERATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYBECLUSTERATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT ModifyBEClusterAttributeRequest : public RpcServiceRequest {
+public:
+	ModifyBEClusterAttributeRequest();
+	~ModifyBEClusterAttributeRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+	std::string getValue() const;
+	void setValue(const std::string &value);
+	std::string getInstanceAttributeType() const;
+	void setInstanceAttributeType(const std::string &instanceAttributeType);
+
+private:
+	long resourceOwnerId_;
+	std::string dBClusterId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+	std::string value_;
+	std::string instanceAttributeType_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYBECLUSTERATTRIBUTEREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/ModifyBEClusterAttributeResult.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_SELECTDB_MODEL_MODIFYBECLUSTERATTRIBUTERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYBECLUSTERATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT ModifyBEClusterAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyBEClusterAttributeResult();
+				explicit ModifyBEClusterAttributeResult(const std::string &payload);
+				~ModifyBEClusterAttributeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYBECLUSTERATTRIBUTERESULT_H_

selectdb/include/alibabacloud/selectdb/model/ModifyDBClusterConfigRequest.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_SELECTDB_MODEL_MODIFYDBCLUSTERCONFIGREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBCLUSTERCONFIGREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT ModifyDBClusterConfigRequest : public RpcServiceRequest {
+public:
+	ModifyDBClusterConfigRequest();
+	~ModifyDBClusterConfigRequest();
+	std::string getConfigKey() const;
+	void setConfigKey(const std::string &configKey);
+	std::string getSwitchTimeMode() const;
+	void setSwitchTimeMode(const std::string &switchTimeMode);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getParameters() const;
+	void setParameters(const std::string &parameters);
+
+private:
+	std::string configKey_;
+	std::string switchTimeMode_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+	std::string dBClusterId_;
+	std::string parameters_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBCLUSTERCONFIGREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/ModifyDBClusterConfigResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SELECTDB_MODEL_MODIFYDBCLUSTERCONFIGRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBCLUSTERCONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT ModifyDBClusterConfigResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					int taskId;
+					std::string dbClusterId;
+					std::string dbInstanceName;
+					std::string dbInstanceId;
+				};
+
+
+				ModifyDBClusterConfigResult();
+				explicit ModifyDBClusterConfigResult(const std::string &payload);
+				~ModifyDBClusterConfigResult();
+				std::string getAccessDeniedDetail()const;
+				Data getData()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string accessDeniedDetail_;
+				Data data_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBCLUSTERCONFIGRESULT_H_

selectdb/include/alibabacloud/selectdb/model/ModifyDBClusterRequest.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_SELECTDB_MODEL_MODIFYDBCLUSTERREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBCLUSTERREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT ModifyDBClusterRequest : public RpcServiceRequest {
+public:
+	ModifyDBClusterRequest();
+	~ModifyDBClusterRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getDBClusterClass() const;
+	void setDBClusterClass(const std::string &dBClusterClass);
+	std::string getCacheSize() const;
+	void setCacheSize(const std::string &cacheSize);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getEngine() const;
+	void setEngine(const std::string &engine);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string dBClusterId_;
+	std::string dBClusterClass_;
+	std::string cacheSize_;
+	std::string regionId_;
+	std::string engine_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBCLUSTERREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/ModifyDBClusterResult.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_SELECTDB_MODEL_MODIFYDBCLUSTERRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBCLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT ModifyDBClusterResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string dBInstanceId;
+					std::string dBClusterId;
+					long orderId;
+				};
+
+
+				ModifyDBClusterResult();
+				explicit ModifyDBClusterResult(const std::string &payload);
+				~ModifyDBClusterResult();
+				std::string getDBInstanceId()const;
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string dBInstanceId_;
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBCLUSTERRESULT_H_

selectdb/include/alibabacloud/selectdb/model/ModifyDBInstanceAttributeRequest.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_SELECTDB_MODEL_MODIFYDBINSTANCEATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBINSTANCEATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT ModifyDBInstanceAttributeRequest : public RpcServiceRequest {
+public:
+	ModifyDBInstanceAttributeRequest();
+	~ModifyDBInstanceAttributeRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+	std::string getValue() const;
+	void setValue(const std::string &value);
+	std::string getInstanceAttributeType() const;
+	void setInstanceAttributeType(const std::string &instanceAttributeType);
+
+private:
+	long resourceOwnerId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+	std::string value_;
+	std::string instanceAttributeType_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBINSTANCEATTRIBUTEREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/ModifyDBInstanceAttributeResult.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_SELECTDB_MODEL_MODIFYDBINSTANCEATTRIBUTERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBINSTANCEATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT ModifyDBInstanceAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyDBInstanceAttributeResult();
+				explicit ModifyDBInstanceAttributeResult(const std::string &payload);
+				~ModifyDBInstanceAttributeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYDBINSTANCEATTRIBUTERESULT_H_

selectdb/include/alibabacloud/selectdb/model/ModifyElasticRuleRequest.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_SELECTDB_MODEL_MODIFYELASTICRULEREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYELASTICRULEREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT ModifyElasticRuleRequest : public RpcServiceRequest {
+public:
+	ModifyElasticRuleRequest();
+	~ModifyElasticRuleRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDbInstanceId() const;
+	void setDbInstanceId(const std::string &dbInstanceId);
+	std::string getProduct() const;
+	void setProduct(const std::string &product);
+	std::string getExecutionPeriod() const;
+	void setExecutionPeriod(const std::string &executionPeriod);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getElasticRuleStartTime() const;
+	void setElasticRuleStartTime(const std::string &elasticRuleStartTime);
+	std::string getClusterClass() const;
+	void setClusterClass(const std::string &clusterClass);
+	long getRuleId() const;
+	void setRuleId(long ruleId);
+
+private:
+	long resourceOwnerId_;
+	std::string regionId_;
+	std::string dbInstanceId_;
+	std::string product_;
+	std::string executionPeriod_;
+	std::string clusterId_;
+	std::string elasticRuleStartTime_;
+	std::string clusterClass_;
+	long ruleId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYELASTICRULEREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/ModifyElasticRuleResult.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_SELECTDB_MODEL_MODIFYELASTICRULERESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYELASTICRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT ModifyElasticRuleResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string clusterId;
+					long ruleId;
+					std::string elasticRuleStartTime;
+					std::string dbInstanceId;
+					std::string executionPeriod;
+					std::string clusterClass;
+				};
+
+
+				ModifyElasticRuleResult();
+				explicit ModifyElasticRuleResult(const std::string &payload);
+				~ModifyElasticRuleResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYELASTICRULERESULT_H_

selectdb/include/alibabacloud/selectdb/model/ModifySecurityIPListRequest.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_SELECTDB_MODEL_MODIFYSECURITYIPLISTREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYSECURITYIPLISTREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT ModifySecurityIPListRequest : public RpcServiceRequest {
+public:
+	ModifySecurityIPListRequest();
+	~ModifySecurityIPListRequest();
+	std::string getModifyMode() const;
+	void setModifyMode(const std::string &modifyMode);
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getGroupName() const;
+	void setGroupName(const std::string &groupName);
+	std::string getSecurityIPList() const;
+	void setSecurityIPList(const std::string &securityIPList);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	std::string modifyMode_;
+	long resourceOwnerId_;
+	std::string groupName_;
+	std::string securityIPList_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYSECURITYIPLISTREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/ModifySecurityIPListResult.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_SELECTDB_MODEL_MODIFYSECURITYIPLISTRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_MODIFYSECURITYIPLISTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT ModifySecurityIPListResult : public ServiceResult
+			{
+			public:
+
+
+				ModifySecurityIPListResult();
+				explicit ModifySecurityIPListResult(const std::string &payload);
+				~ModifySecurityIPListResult();
+				std::string getGroupName()const;
+				std::string getSecurityIPType()const;
+				std::string getGroupTag()const;
+				long getTaskId()const;
+				std::string getSecurityIPList()const;
+				std::string getWhitelistNetType()const;
+				std::string getDBInstanceName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string groupName_;
+				std::string securityIPType_;
+				std::string groupTag_;
+				long taskId_;
+				std::string securityIPList_;
+				std::string whitelistNetType_;
+				std::string dBInstanceName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_MODIFYSECURITYIPLISTRESULT_H_

selectdb/include/alibabacloud/selectdb/model/ReleaseInstancePublicConnectionRequest.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_SELECTDB_MODEL_RELEASEINSTANCEPUBLICCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_RELEASEINSTANCEPUBLICCONNECTIONREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT ReleaseInstancePublicConnectionRequest : public RpcServiceRequest {
+public:
+	ReleaseInstancePublicConnectionRequest();
+	~ReleaseInstancePublicConnectionRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getConnectionString() const;
+	void setConnectionString(const std::string &connectionString);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string connectionString_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_RELEASEINSTANCEPUBLICCONNECTIONREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/ReleaseInstancePublicConnectionResult.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_SELECTDB_MODEL_RELEASEINSTANCEPUBLICCONNECTIONRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_RELEASEINSTANCEPUBLICCONNECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT ReleaseInstancePublicConnectionResult : public ServiceResult
+			{
+			public:
+
+
+				ReleaseInstancePublicConnectionResult();
+				explicit ReleaseInstancePublicConnectionResult(const std::string &payload);
+				~ReleaseInstancePublicConnectionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_RELEASEINSTANCEPUBLICCONNECTIONRESULT_H_

selectdb/include/alibabacloud/selectdb/model/ResetAccountPasswordRequest.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_SELECTDB_MODEL_RESETACCOUNTPASSWORDREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_RESETACCOUNTPASSWORDREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT ResetAccountPasswordRequest : public RpcServiceRequest {
+public:
+	ResetAccountPasswordRequest();
+	~ResetAccountPasswordRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccountPassword() const;
+	void setAccountPassword(const std::string &accountPassword);
+	std::string getAccountName() const;
+	void setAccountName(const std::string &accountName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string accountPassword_;
+	std::string accountName_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_RESETACCOUNTPASSWORDREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/ResetAccountPasswordResult.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_SELECTDB_MODEL_RESETACCOUNTPASSWORDRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_RESETACCOUNTPASSWORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT ResetAccountPasswordResult : public ServiceResult
+			{
+			public:
+
+
+				ResetAccountPasswordResult();
+				explicit ResetAccountPasswordResult(const std::string &payload);
+				~ResetAccountPasswordResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_RESETACCOUNTPASSWORDRESULT_H_

selectdb/include/alibabacloud/selectdb/model/RestartDBClusterRequest.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_SELECTDB_MODEL_RESTARTDBCLUSTERREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_RESTARTDBCLUSTERREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT RestartDBClusterRequest : public RpcServiceRequest {
+public:
+	RestartDBClusterRequest();
+	~RestartDBClusterRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string dBClusterId_;
+	std::string resourceGroupId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_RESTARTDBCLUSTERREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/RestartDBClusterResult.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_SELECTDB_MODEL_RESTARTDBCLUSTERRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_RESTARTDBCLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT RestartDBClusterResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string dBInstanceId;
+					std::string dBClusterId;
+				};
+
+
+				RestartDBClusterResult();
+				explicit RestartDBClusterResult(const std::string &payload);
+				~RestartDBClusterResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_RESTARTDBCLUSTERRESULT_H_

selectdb/include/alibabacloud/selectdb/model/StartBEClusterRequest.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_SELECTDB_MODEL_STARTBECLUSTERREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_STARTBECLUSTERREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT StartBEClusterRequest : public RpcServiceRequest {
+public:
+	StartBEClusterRequest();
+	~StartBEClusterRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string dBClusterId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_STARTBECLUSTERREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/StartBEClusterResult.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_SELECTDB_MODEL_STARTBECLUSTERRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_STARTBECLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT StartBEClusterResult : public ServiceResult
+			{
+			public:
+
+
+				StartBEClusterResult();
+				explicit StartBEClusterResult(const std::string &payload);
+				~StartBEClusterResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_STARTBECLUSTERRESULT_H_

selectdb/include/alibabacloud/selectdb/model/StopBEClusterRequest.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_SELECTDB_MODEL_STOPBECLUSTERREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_STOPBECLUSTERREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT StopBEClusterRequest : public RpcServiceRequest {
+public:
+	StopBEClusterRequest();
+	~StopBEClusterRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string dBClusterId_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_STOPBECLUSTERREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/StopBEClusterResult.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_SELECTDB_MODEL_STOPBECLUSTERRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_STOPBECLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT StopBEClusterResult : public ServiceResult
+			{
+			public:
+
+
+				StopBEClusterResult();
+				explicit StopBEClusterResult(const std::string &payload);
+				~StopBEClusterResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_STOPBECLUSTERRESULT_H_

selectdb/include/alibabacloud/selectdb/model/UpgradeDBInstanceEngineVersionRequest.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_SELECTDB_MODEL_UPGRADEDBINSTANCEENGINEVERSIONREQUEST_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_UPGRADEDBINSTANCEENGINEVERSIONREQUEST_H_
+
+#include <alibabacloud/selectdb/SelectdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Selectdb {
+namespace Model {
+class ALIBABACLOUD_SELECTDB_EXPORT UpgradeDBInstanceEngineVersionRequest : public RpcServiceRequest {
+public:
+	UpgradeDBInstanceEngineVersionRequest();
+	~UpgradeDBInstanceEngineVersionRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getEngineVersion() const;
+	void setEngineVersion(const std::string &engineVersion);
+	std::string getSwitchTimeMode() const;
+	void setSwitchTimeMode(const std::string &switchTimeMode);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDBInstanceId() const;
+	void setDBInstanceId(const std::string &dBInstanceId);
+
+private:
+	long resourceOwnerId_;
+	std::string engineVersion_;
+	std::string switchTimeMode_;
+	std::string regionId_;
+	std::string dBInstanceId_;
+};
+} // namespace Model
+} // namespace Selectdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_UPGRADEDBINSTANCEENGINEVERSIONREQUEST_H_

selectdb/include/alibabacloud/selectdb/model/UpgradeDBInstanceEngineVersionResult.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_SELECTDB_MODEL_UPGRADEDBINSTANCEENGINEVERSIONRESULT_H_
+#define ALIBABACLOUD_SELECTDB_MODEL_UPGRADEDBINSTANCEENGINEVERSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/selectdb/SelectdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Selectdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SELECTDB_EXPORT UpgradeDBInstanceEngineVersionResult : public ServiceResult
+			{
+			public:
+
+
+				UpgradeDBInstanceEngineVersionResult();
+				explicit UpgradeDBInstanceEngineVersionResult(const std::string &payload);
+				~UpgradeDBInstanceEngineVersionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SELECTDB_MODEL_UPGRADEDBINSTANCEENGINEVERSIONRESULT_H_

selectdb/src/SelectdbClient.cc

@@ -0,0 +1,1241 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/SelectdbClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Selectdb;
+using namespace AlibabaCloud::Selectdb::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "selectdb";
+}
+
+SelectdbClient::SelectdbClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+SelectdbClient::SelectdbClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+SelectdbClient::SelectdbClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+SelectdbClient::~SelectdbClient()
+{}
+
+SelectdbClient::AllocateInstancePublicConnectionOutcome SelectdbClient::allocateInstancePublicConnection(const AllocateInstancePublicConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AllocateInstancePublicConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AllocateInstancePublicConnectionOutcome(AllocateInstancePublicConnectionResult(outcome.result()));
+	else
+		return AllocateInstancePublicConnectionOutcome(outcome.error());
+}
+
+void SelectdbClient::allocateInstancePublicConnectionAsync(const AllocateInstancePublicConnectionRequest& request, const AllocateInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, allocateInstancePublicConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::AllocateInstancePublicConnectionOutcomeCallable SelectdbClient::allocateInstancePublicConnectionCallable(const AllocateInstancePublicConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AllocateInstancePublicConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->allocateInstancePublicConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::CheckCreateDBInstanceOutcome SelectdbClient::checkCreateDBInstance(const CheckCreateDBInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CheckCreateDBInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CheckCreateDBInstanceOutcome(CheckCreateDBInstanceResult(outcome.result()));
+	else
+		return CheckCreateDBInstanceOutcome(outcome.error());
+}
+
+void SelectdbClient::checkCreateDBInstanceAsync(const CheckCreateDBInstanceRequest& request, const CheckCreateDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, checkCreateDBInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::CheckCreateDBInstanceOutcomeCallable SelectdbClient::checkCreateDBInstanceCallable(const CheckCreateDBInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CheckCreateDBInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->checkCreateDBInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::CheckServiceLinkedRoleOutcome SelectdbClient::checkServiceLinkedRole(const CheckServiceLinkedRoleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CheckServiceLinkedRoleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CheckServiceLinkedRoleOutcome(CheckServiceLinkedRoleResult(outcome.result()));
+	else
+		return CheckServiceLinkedRoleOutcome(outcome.error());
+}
+
+void SelectdbClient::checkServiceLinkedRoleAsync(const CheckServiceLinkedRoleRequest& request, const CheckServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, checkServiceLinkedRole(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::CheckServiceLinkedRoleOutcomeCallable SelectdbClient::checkServiceLinkedRoleCallable(const CheckServiceLinkedRoleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CheckServiceLinkedRoleOutcome()>>(
+			[this, request]()
+			{
+			return this->checkServiceLinkedRole(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::CreateDBClusterOutcome SelectdbClient::createDBCluster(const CreateDBClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDBClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDBClusterOutcome(CreateDBClusterResult(outcome.result()));
+	else
+		return CreateDBClusterOutcome(outcome.error());
+}
+
+void SelectdbClient::createDBClusterAsync(const CreateDBClusterRequest& request, const CreateDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDBCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::CreateDBClusterOutcomeCallable SelectdbClient::createDBClusterCallable(const CreateDBClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDBClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->createDBCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::CreateDBInstanceOutcome SelectdbClient::createDBInstance(const CreateDBInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDBInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDBInstanceOutcome(CreateDBInstanceResult(outcome.result()));
+	else
+		return CreateDBInstanceOutcome(outcome.error());
+}
+
+void SelectdbClient::createDBInstanceAsync(const CreateDBInstanceRequest& request, const CreateDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDBInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::CreateDBInstanceOutcomeCallable SelectdbClient::createDBInstanceCallable(const CreateDBInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDBInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->createDBInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::CreateElasticRuleOutcome SelectdbClient::createElasticRule(const CreateElasticRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateElasticRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateElasticRuleOutcome(CreateElasticRuleResult(outcome.result()));
+	else
+		return CreateElasticRuleOutcome(outcome.error());
+}
+
+void SelectdbClient::createElasticRuleAsync(const CreateElasticRuleRequest& request, const CreateElasticRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createElasticRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::CreateElasticRuleOutcomeCallable SelectdbClient::createElasticRuleCallable(const CreateElasticRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateElasticRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->createElasticRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::CreateServiceLinkedRoleForSelectDBOutcome SelectdbClient::createServiceLinkedRoleForSelectDB(const CreateServiceLinkedRoleForSelectDBRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateServiceLinkedRoleForSelectDBOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateServiceLinkedRoleForSelectDBOutcome(CreateServiceLinkedRoleForSelectDBResult(outcome.result()));
+	else
+		return CreateServiceLinkedRoleForSelectDBOutcome(outcome.error());
+}
+
+void SelectdbClient::createServiceLinkedRoleForSelectDBAsync(const CreateServiceLinkedRoleForSelectDBRequest& request, const CreateServiceLinkedRoleForSelectDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createServiceLinkedRoleForSelectDB(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::CreateServiceLinkedRoleForSelectDBOutcomeCallable SelectdbClient::createServiceLinkedRoleForSelectDBCallable(const CreateServiceLinkedRoleForSelectDBRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateServiceLinkedRoleForSelectDBOutcome()>>(
+			[this, request]()
+			{
+			return this->createServiceLinkedRoleForSelectDB(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DeleteDBClusterOutcome SelectdbClient::deleteDBCluster(const DeleteDBClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDBClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDBClusterOutcome(DeleteDBClusterResult(outcome.result()));
+	else
+		return DeleteDBClusterOutcome(outcome.error());
+}
+
+void SelectdbClient::deleteDBClusterAsync(const DeleteDBClusterRequest& request, const DeleteDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDBCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DeleteDBClusterOutcomeCallable SelectdbClient::deleteDBClusterCallable(const DeleteDBClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDBClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDBCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DeleteDBInstanceOutcome SelectdbClient::deleteDBInstance(const DeleteDBInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDBInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDBInstanceOutcome(DeleteDBInstanceResult(outcome.result()));
+	else
+		return DeleteDBInstanceOutcome(outcome.error());
+}
+
+void SelectdbClient::deleteDBInstanceAsync(const DeleteDBInstanceRequest& request, const DeleteDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDBInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DeleteDBInstanceOutcomeCallable SelectdbClient::deleteDBInstanceCallable(const DeleteDBInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDBInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDBInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DeleteElasticRuleOutcome SelectdbClient::deleteElasticRule(const DeleteElasticRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteElasticRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteElasticRuleOutcome(DeleteElasticRuleResult(outcome.result()));
+	else
+		return DeleteElasticRuleOutcome(outcome.error());
+}
+
+void SelectdbClient::deleteElasticRuleAsync(const DeleteElasticRuleRequest& request, const DeleteElasticRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteElasticRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DeleteElasticRuleOutcomeCallable SelectdbClient::deleteElasticRuleCallable(const DeleteElasticRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteElasticRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteElasticRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DescribeAllDBInstanceClassOutcome SelectdbClient::describeAllDBInstanceClass(const DescribeAllDBInstanceClassRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAllDBInstanceClassOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAllDBInstanceClassOutcome(DescribeAllDBInstanceClassResult(outcome.result()));
+	else
+		return DescribeAllDBInstanceClassOutcome(outcome.error());
+}
+
+void SelectdbClient::describeAllDBInstanceClassAsync(const DescribeAllDBInstanceClassRequest& request, const DescribeAllDBInstanceClassAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAllDBInstanceClass(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DescribeAllDBInstanceClassOutcomeCallable SelectdbClient::describeAllDBInstanceClassCallable(const DescribeAllDBInstanceClassRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAllDBInstanceClassOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAllDBInstanceClass(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DescribeDBClusterConfigOutcome SelectdbClient::describeDBClusterConfig(const DescribeDBClusterConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBClusterConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBClusterConfigOutcome(DescribeDBClusterConfigResult(outcome.result()));
+	else
+		return DescribeDBClusterConfigOutcome(outcome.error());
+}
+
+void SelectdbClient::describeDBClusterConfigAsync(const DescribeDBClusterConfigRequest& request, const DescribeDBClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBClusterConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DescribeDBClusterConfigOutcomeCallable SelectdbClient::describeDBClusterConfigCallable(const DescribeDBClusterConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBClusterConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBClusterConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DescribeDBClusterConfigChangeLogsOutcome SelectdbClient::describeDBClusterConfigChangeLogs(const DescribeDBClusterConfigChangeLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBClusterConfigChangeLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBClusterConfigChangeLogsOutcome(DescribeDBClusterConfigChangeLogsResult(outcome.result()));
+	else
+		return DescribeDBClusterConfigChangeLogsOutcome(outcome.error());
+}
+
+void SelectdbClient::describeDBClusterConfigChangeLogsAsync(const DescribeDBClusterConfigChangeLogsRequest& request, const DescribeDBClusterConfigChangeLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBClusterConfigChangeLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DescribeDBClusterConfigChangeLogsOutcomeCallable SelectdbClient::describeDBClusterConfigChangeLogsCallable(const DescribeDBClusterConfigChangeLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBClusterConfigChangeLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBClusterConfigChangeLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DescribeDBInstanceAttributeOutcome SelectdbClient::describeDBInstanceAttribute(const DescribeDBInstanceAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBInstanceAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBInstanceAttributeOutcome(DescribeDBInstanceAttributeResult(outcome.result()));
+	else
+		return DescribeDBInstanceAttributeOutcome(outcome.error());
+}
+
+void SelectdbClient::describeDBInstanceAttributeAsync(const DescribeDBInstanceAttributeRequest& request, const DescribeDBInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBInstanceAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DescribeDBInstanceAttributeOutcomeCallable SelectdbClient::describeDBInstanceAttributeCallable(const DescribeDBInstanceAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBInstanceAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBInstanceAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DescribeDBInstanceNetInfoOutcome SelectdbClient::describeDBInstanceNetInfo(const DescribeDBInstanceNetInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBInstanceNetInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBInstanceNetInfoOutcome(DescribeDBInstanceNetInfoResult(outcome.result()));
+	else
+		return DescribeDBInstanceNetInfoOutcome(outcome.error());
+}
+
+void SelectdbClient::describeDBInstanceNetInfoAsync(const DescribeDBInstanceNetInfoRequest& request, const DescribeDBInstanceNetInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBInstanceNetInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DescribeDBInstanceNetInfoOutcomeCallable SelectdbClient::describeDBInstanceNetInfoCallable(const DescribeDBInstanceNetInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBInstanceNetInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBInstanceNetInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DescribeDBInstancesOutcome SelectdbClient::describeDBInstances(const DescribeDBInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBInstancesOutcome(DescribeDBInstancesResult(outcome.result()));
+	else
+		return DescribeDBInstancesOutcome(outcome.error());
+}
+
+void SelectdbClient::describeDBInstancesAsync(const DescribeDBInstancesRequest& request, const DescribeDBInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DescribeDBInstancesOutcomeCallable SelectdbClient::describeDBInstancesCallable(const DescribeDBInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DescribeElasticRulesOutcome SelectdbClient::describeElasticRules(const DescribeElasticRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeElasticRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeElasticRulesOutcome(DescribeElasticRulesResult(outcome.result()));
+	else
+		return DescribeElasticRulesOutcome(outcome.error());
+}
+
+void SelectdbClient::describeElasticRulesAsync(const DescribeElasticRulesRequest& request, const DescribeElasticRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeElasticRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DescribeElasticRulesOutcomeCallable SelectdbClient::describeElasticRulesCallable(const DescribeElasticRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeElasticRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeElasticRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::DescribeSecurityIPListOutcome SelectdbClient::describeSecurityIPList(const DescribeSecurityIPListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSecurityIPListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSecurityIPListOutcome(DescribeSecurityIPListResult(outcome.result()));
+	else
+		return DescribeSecurityIPListOutcome(outcome.error());
+}
+
+void SelectdbClient::describeSecurityIPListAsync(const DescribeSecurityIPListRequest& request, const DescribeSecurityIPListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSecurityIPList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::DescribeSecurityIPListOutcomeCallable SelectdbClient::describeSecurityIPListCallable(const DescribeSecurityIPListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSecurityIPListOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSecurityIPList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::EnDisableScalingRulesOutcome SelectdbClient::enDisableScalingRules(const EnDisableScalingRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnDisableScalingRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnDisableScalingRulesOutcome(EnDisableScalingRulesResult(outcome.result()));
+	else
+		return EnDisableScalingRulesOutcome(outcome.error());
+}
+
+void SelectdbClient::enDisableScalingRulesAsync(const EnDisableScalingRulesRequest& request, const EnDisableScalingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enDisableScalingRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::EnDisableScalingRulesOutcomeCallable SelectdbClient::enDisableScalingRulesCallable(const EnDisableScalingRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnDisableScalingRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->enDisableScalingRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::GetCreateBEClusterInquiryOutcome SelectdbClient::getCreateBEClusterInquiry(const GetCreateBEClusterInquiryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetCreateBEClusterInquiryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetCreateBEClusterInquiryOutcome(GetCreateBEClusterInquiryResult(outcome.result()));
+	else
+		return GetCreateBEClusterInquiryOutcome(outcome.error());
+}
+
+void SelectdbClient::getCreateBEClusterInquiryAsync(const GetCreateBEClusterInquiryRequest& request, const GetCreateBEClusterInquiryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getCreateBEClusterInquiry(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::GetCreateBEClusterInquiryOutcomeCallable SelectdbClient::getCreateBEClusterInquiryCallable(const GetCreateBEClusterInquiryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetCreateBEClusterInquiryOutcome()>>(
+			[this, request]()
+			{
+			return this->getCreateBEClusterInquiry(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::GetModifyBEClusterInquiryOutcome SelectdbClient::getModifyBEClusterInquiry(const GetModifyBEClusterInquiryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetModifyBEClusterInquiryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetModifyBEClusterInquiryOutcome(GetModifyBEClusterInquiryResult(outcome.result()));
+	else
+		return GetModifyBEClusterInquiryOutcome(outcome.error());
+}
+
+void SelectdbClient::getModifyBEClusterInquiryAsync(const GetModifyBEClusterInquiryRequest& request, const GetModifyBEClusterInquiryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getModifyBEClusterInquiry(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::GetModifyBEClusterInquiryOutcomeCallable SelectdbClient::getModifyBEClusterInquiryCallable(const GetModifyBEClusterInquiryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetModifyBEClusterInquiryOutcome()>>(
+			[this, request]()
+			{
+			return this->getModifyBEClusterInquiry(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::ModifyBEClusterAttributeOutcome SelectdbClient::modifyBEClusterAttribute(const ModifyBEClusterAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyBEClusterAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyBEClusterAttributeOutcome(ModifyBEClusterAttributeResult(outcome.result()));
+	else
+		return ModifyBEClusterAttributeOutcome(outcome.error());
+}
+
+void SelectdbClient::modifyBEClusterAttributeAsync(const ModifyBEClusterAttributeRequest& request, const ModifyBEClusterAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyBEClusterAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::ModifyBEClusterAttributeOutcomeCallable SelectdbClient::modifyBEClusterAttributeCallable(const ModifyBEClusterAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyBEClusterAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyBEClusterAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::ModifyDBClusterOutcome SelectdbClient::modifyDBCluster(const ModifyDBClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDBClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDBClusterOutcome(ModifyDBClusterResult(outcome.result()));
+	else
+		return ModifyDBClusterOutcome(outcome.error());
+}
+
+void SelectdbClient::modifyDBClusterAsync(const ModifyDBClusterRequest& request, const ModifyDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDBCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::ModifyDBClusterOutcomeCallable SelectdbClient::modifyDBClusterCallable(const ModifyDBClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDBClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDBCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::ModifyDBClusterConfigOutcome SelectdbClient::modifyDBClusterConfig(const ModifyDBClusterConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDBClusterConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDBClusterConfigOutcome(ModifyDBClusterConfigResult(outcome.result()));
+	else
+		return ModifyDBClusterConfigOutcome(outcome.error());
+}
+
+void SelectdbClient::modifyDBClusterConfigAsync(const ModifyDBClusterConfigRequest& request, const ModifyDBClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDBClusterConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::ModifyDBClusterConfigOutcomeCallable SelectdbClient::modifyDBClusterConfigCallable(const ModifyDBClusterConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDBClusterConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDBClusterConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::ModifyDBInstanceAttributeOutcome SelectdbClient::modifyDBInstanceAttribute(const ModifyDBInstanceAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDBInstanceAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDBInstanceAttributeOutcome(ModifyDBInstanceAttributeResult(outcome.result()));
+	else
+		return ModifyDBInstanceAttributeOutcome(outcome.error());
+}
+
+void SelectdbClient::modifyDBInstanceAttributeAsync(const ModifyDBInstanceAttributeRequest& request, const ModifyDBInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDBInstanceAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::ModifyDBInstanceAttributeOutcomeCallable SelectdbClient::modifyDBInstanceAttributeCallable(const ModifyDBInstanceAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDBInstanceAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDBInstanceAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::ModifyElasticRuleOutcome SelectdbClient::modifyElasticRule(const ModifyElasticRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyElasticRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyElasticRuleOutcome(ModifyElasticRuleResult(outcome.result()));
+	else
+		return ModifyElasticRuleOutcome(outcome.error());
+}
+
+void SelectdbClient::modifyElasticRuleAsync(const ModifyElasticRuleRequest& request, const ModifyElasticRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyElasticRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::ModifyElasticRuleOutcomeCallable SelectdbClient::modifyElasticRuleCallable(const ModifyElasticRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyElasticRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyElasticRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::ModifySecurityIPListOutcome SelectdbClient::modifySecurityIPList(const ModifySecurityIPListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifySecurityIPListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifySecurityIPListOutcome(ModifySecurityIPListResult(outcome.result()));
+	else
+		return ModifySecurityIPListOutcome(outcome.error());
+}
+
+void SelectdbClient::modifySecurityIPListAsync(const ModifySecurityIPListRequest& request, const ModifySecurityIPListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifySecurityIPList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::ModifySecurityIPListOutcomeCallable SelectdbClient::modifySecurityIPListCallable(const ModifySecurityIPListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifySecurityIPListOutcome()>>(
+			[this, request]()
+			{
+			return this->modifySecurityIPList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::ReleaseInstancePublicConnectionOutcome SelectdbClient::releaseInstancePublicConnection(const ReleaseInstancePublicConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReleaseInstancePublicConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReleaseInstancePublicConnectionOutcome(ReleaseInstancePublicConnectionResult(outcome.result()));
+	else
+		return ReleaseInstancePublicConnectionOutcome(outcome.error());
+}
+
+void SelectdbClient::releaseInstancePublicConnectionAsync(const ReleaseInstancePublicConnectionRequest& request, const ReleaseInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, releaseInstancePublicConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::ReleaseInstancePublicConnectionOutcomeCallable SelectdbClient::releaseInstancePublicConnectionCallable(const ReleaseInstancePublicConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReleaseInstancePublicConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->releaseInstancePublicConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::ResetAccountPasswordOutcome SelectdbClient::resetAccountPassword(const ResetAccountPasswordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResetAccountPasswordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResetAccountPasswordOutcome(ResetAccountPasswordResult(outcome.result()));
+	else
+		return ResetAccountPasswordOutcome(outcome.error());
+}
+
+void SelectdbClient::resetAccountPasswordAsync(const ResetAccountPasswordRequest& request, const ResetAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resetAccountPassword(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::ResetAccountPasswordOutcomeCallable SelectdbClient::resetAccountPasswordCallable(const ResetAccountPasswordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResetAccountPasswordOutcome()>>(
+			[this, request]()
+			{
+			return this->resetAccountPassword(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::RestartDBClusterOutcome SelectdbClient::restartDBCluster(const RestartDBClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RestartDBClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RestartDBClusterOutcome(RestartDBClusterResult(outcome.result()));
+	else
+		return RestartDBClusterOutcome(outcome.error());
+}
+
+void SelectdbClient::restartDBClusterAsync(const RestartDBClusterRequest& request, const RestartDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, restartDBCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::RestartDBClusterOutcomeCallable SelectdbClient::restartDBClusterCallable(const RestartDBClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RestartDBClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->restartDBCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::StartBEClusterOutcome SelectdbClient::startBECluster(const StartBEClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartBEClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartBEClusterOutcome(StartBEClusterResult(outcome.result()));
+	else
+		return StartBEClusterOutcome(outcome.error());
+}
+
+void SelectdbClient::startBEClusterAsync(const StartBEClusterRequest& request, const StartBEClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startBECluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::StartBEClusterOutcomeCallable SelectdbClient::startBEClusterCallable(const StartBEClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartBEClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->startBECluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::StopBEClusterOutcome SelectdbClient::stopBECluster(const StopBEClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopBEClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopBEClusterOutcome(StopBEClusterResult(outcome.result()));
+	else
+		return StopBEClusterOutcome(outcome.error());
+}
+
+void SelectdbClient::stopBEClusterAsync(const StopBEClusterRequest& request, const StopBEClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopBECluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::StopBEClusterOutcomeCallable SelectdbClient::stopBEClusterCallable(const StopBEClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopBEClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->stopBECluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SelectdbClient::UpgradeDBInstanceEngineVersionOutcome SelectdbClient::upgradeDBInstanceEngineVersion(const UpgradeDBInstanceEngineVersionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpgradeDBInstanceEngineVersionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpgradeDBInstanceEngineVersionOutcome(UpgradeDBInstanceEngineVersionResult(outcome.result()));
+	else
+		return UpgradeDBInstanceEngineVersionOutcome(outcome.error());
+}
+
+void SelectdbClient::upgradeDBInstanceEngineVersionAsync(const UpgradeDBInstanceEngineVersionRequest& request, const UpgradeDBInstanceEngineVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, upgradeDBInstanceEngineVersion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SelectdbClient::UpgradeDBInstanceEngineVersionOutcomeCallable SelectdbClient::upgradeDBInstanceEngineVersionCallable(const UpgradeDBInstanceEngineVersionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpgradeDBInstanceEngineVersionOutcome()>>(
+			[this, request]()
+			{
+			return this->upgradeDBInstanceEngineVersion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

selectdb/src/model/AllocateInstancePublicConnectionRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/AllocateInstancePublicConnectionRequest.h>
+
+using AlibabaCloud::Selectdb::Model::AllocateInstancePublicConnectionRequest;
+
+AllocateInstancePublicConnectionRequest::AllocateInstancePublicConnectionRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "AllocateInstancePublicConnection") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AllocateInstancePublicConnectionRequest::~AllocateInstancePublicConnectionRequest() {}
+
+std::string AllocateInstancePublicConnectionRequest::getConnectionStringPrefix() const {
+  return connectionStringPrefix_;
+}
+
+void AllocateInstancePublicConnectionRequest::setConnectionStringPrefix(const std::string &connectionStringPrefix) {
+  connectionStringPrefix_ = connectionStringPrefix;
+  setParameter(std::string("ConnectionStringPrefix"), connectionStringPrefix);
+}
+
+long AllocateInstancePublicConnectionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AllocateInstancePublicConnectionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string AllocateInstancePublicConnectionRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AllocateInstancePublicConnectionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AllocateInstancePublicConnectionRequest::getNetType() const {
+  return netType_;
+}
+
+void AllocateInstancePublicConnectionRequest::setNetType(const std::string &netType) {
+  netType_ = netType;
+  setParameter(std::string("NetType"), netType);
+}
+
+std::string AllocateInstancePublicConnectionRequest::getDBInstanceId() const {
+  return dBInstanceId_;
+}
+
+void AllocateInstancePublicConnectionRequest::setDBInstanceId(const std::string &dBInstanceId) {
+  dBInstanceId_ = dBInstanceId;
+  setParameter(std::string("DBInstanceId"), dBInstanceId);
+}
+

selectdb/src/model/AllocateInstancePublicConnectionResult.cc

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

selectdb/src/model/CheckCreateDBInstanceRequest.cc

@@ -0,0 +1,180 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/CheckCreateDBInstanceRequest.h>
+
+using AlibabaCloud::Selectdb::Model::CheckCreateDBInstanceRequest;
+
+CheckCreateDBInstanceRequest::CheckCreateDBInstanceRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "CheckCreateDBInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CheckCreateDBInstanceRequest::~CheckCreateDBInstanceRequest() {}
+
+long CheckCreateDBInstanceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CheckCreateDBInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CheckCreateDBInstanceRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CheckCreateDBInstanceRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CheckCreateDBInstanceRequest::getConnectionString() const {
+  return connectionString_;
+}
+
+void CheckCreateDBInstanceRequest::setConnectionString(const std::string &connectionString) {
+  connectionString_ = connectionString;
+  setParameter(std::string("ConnectionString"), connectionString);
+}
+
+std::string CheckCreateDBInstanceRequest::getEngineVersion() const {
+  return engineVersion_;
+}
+
+void CheckCreateDBInstanceRequest::setEngineVersion(const std::string &engineVersion) {
+  engineVersion_ = engineVersion;
+  setParameter(std::string("EngineVersion"), engineVersion);
+}
+
+int CheckCreateDBInstanceRequest::getCacheSize() const {
+  return cacheSize_;
+}
+
+void CheckCreateDBInstanceRequest::setCacheSize(int cacheSize) {
+  cacheSize_ = cacheSize;
+  setParameter(std::string("CacheSize"), std::to_string(cacheSize));
+}
+
+std::string CheckCreateDBInstanceRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CheckCreateDBInstanceRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CheckCreateDBInstanceRequest::getEngine() const {
+  return engine_;
+}
+
+void CheckCreateDBInstanceRequest::setEngine(const std::string &engine) {
+  engine_ = engine;
+  setParameter(std::string("Engine"), engine);
+}
+
+std::string CheckCreateDBInstanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CheckCreateDBInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CheckCreateDBInstanceRequest::getDBInstanceDescription() const {
+  return dBInstanceDescription_;
+}
+
+void CheckCreateDBInstanceRequest::setDBInstanceDescription(const std::string &dBInstanceDescription) {
+  dBInstanceDescription_ = dBInstanceDescription;
+  setParameter(std::string("DBInstanceDescription"), dBInstanceDescription);
+}
+
+std::string CheckCreateDBInstanceRequest::getPeriod() const {
+  return period_;
+}
+
+void CheckCreateDBInstanceRequest::setPeriod(const std::string &period) {
+  period_ = period;
+  setParameter(std::string("Period"), period);
+}
+
+int CheckCreateDBInstanceRequest::getUsedTime() const {
+  return usedTime_;
+}
+
+void CheckCreateDBInstanceRequest::setUsedTime(int usedTime) {
+  usedTime_ = usedTime;
+  setParameter(std::string("UsedTime"), std::to_string(usedTime));
+}
+
+std::string CheckCreateDBInstanceRequest::getDBInstanceClass() const {
+  return dBInstanceClass_;
+}
+
+void CheckCreateDBInstanceRequest::setDBInstanceClass(const std::string &dBInstanceClass) {
+  dBInstanceClass_ = dBInstanceClass;
+  setParameter(std::string("DBInstanceClass"), dBInstanceClass);
+}
+
+std::string CheckCreateDBInstanceRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CheckCreateDBInstanceRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CheckCreateDBInstanceRequest::getSecurityIPList() const {
+  return securityIPList_;
+}
+
+void CheckCreateDBInstanceRequest::setSecurityIPList(const std::string &securityIPList) {
+  securityIPList_ = securityIPList;
+  setParameter(std::string("SecurityIPList"), securityIPList);
+}
+
+std::string CheckCreateDBInstanceRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CheckCreateDBInstanceRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string CheckCreateDBInstanceRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void CheckCreateDBInstanceRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
+std::string CheckCreateDBInstanceRequest::getChargeType() const {
+  return chargeType_;
+}
+
+void CheckCreateDBInstanceRequest::setChargeType(const std::string &chargeType) {
+  chargeType_ = chargeType;
+  setParameter(std::string("ChargeType"), chargeType);
+}
+

selectdb/src/model/CheckCreateDBInstanceResult.cc

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

selectdb/src/model/CheckServiceLinkedRoleRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/CheckServiceLinkedRoleRequest.h>
+
+using AlibabaCloud::Selectdb::Model::CheckServiceLinkedRoleRequest;
+
+CheckServiceLinkedRoleRequest::CheckServiceLinkedRoleRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "CheckServiceLinkedRole") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CheckServiceLinkedRoleRequest::~CheckServiceLinkedRoleRequest() {}
+
+long CheckServiceLinkedRoleRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CheckServiceLinkedRoleRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CheckServiceLinkedRoleRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CheckServiceLinkedRoleRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+

selectdb/src/model/CheckServiceLinkedRoleResult.cc

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

selectdb/src/model/CreateDBClusterRequest.cc

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/CreateDBClusterRequest.h>
+
+using AlibabaCloud::Selectdb::Model::CreateDBClusterRequest;
+
+CreateDBClusterRequest::CreateDBClusterRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "CreateDBCluster") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateDBClusterRequest::~CreateDBClusterRequest() {}
+
+std::string CreateDBClusterRequest::getDBClusterDescription() const {
+  return dBClusterDescription_;
+}
+
+void CreateDBClusterRequest::setDBClusterDescription(const std::string &dBClusterDescription) {
+  dBClusterDescription_ = dBClusterDescription;
+  setParameter(std::string("DBClusterDescription"), dBClusterDescription);
+}
+
+long CreateDBClusterRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateDBClusterRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateDBClusterRequest::getEngineVersion() const {
+  return engineVersion_;
+}
+
+void CreateDBClusterRequest::setEngineVersion(const std::string &engineVersion) {
+  engineVersion_ = engineVersion;
+  setParameter(std::string("EngineVersion"), engineVersion);
+}
+
+std::string CreateDBClusterRequest::getCacheSize() const {
+  return cacheSize_;
+}
+
+void CreateDBClusterRequest::setCacheSize(const std::string &cacheSize) {
+  cacheSize_ = cacheSize;
+  setParameter(std::string("CacheSize"), cacheSize);
+}
+
+std::string CreateDBClusterRequest::getEngine() const {
+  return engine_;
+}
+
+void CreateDBClusterRequest::setEngine(const std::string &engine) {
+  engine_ = engine;
+  setParameter(std::string("Engine"), engine);
+}
+
+std::string CreateDBClusterRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateDBClusterRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateDBClusterRequest::getDBInstanceId() const {
+  return dBInstanceId_;
+}
+
+void CreateDBClusterRequest::setDBInstanceId(const std::string &dBInstanceId) {
+  dBInstanceId_ = dBInstanceId;
+  setBodyParameter(std::string("DBInstanceId"), dBInstanceId);
+}
+
+std::string CreateDBClusterRequest::getPeriod() const {
+  return period_;
+}
+
+void CreateDBClusterRequest::setPeriod(const std::string &period) {
+  period_ = period;
+  setParameter(std::string("Period"), period);
+}
+
+std::string CreateDBClusterRequest::getDBClusterClass() const {
+  return dBClusterClass_;
+}
+
+void CreateDBClusterRequest::setDBClusterClass(const std::string &dBClusterClass) {
+  dBClusterClass_ = dBClusterClass;
+  setParameter(std::string("DBClusterClass"), dBClusterClass);
+}
+
+std::string CreateDBClusterRequest::getUsedTime() const {
+  return usedTime_;
+}
+
+void CreateDBClusterRequest::setUsedTime(const std::string &usedTime) {
+  usedTime_ = usedTime;
+  setParameter(std::string("UsedTime"), usedTime);
+}
+
+std::string CreateDBClusterRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateDBClusterRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CreateDBClusterRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateDBClusterRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string CreateDBClusterRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void CreateDBClusterRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
+std::string CreateDBClusterRequest::getChargeType() const {
+  return chargeType_;
+}
+
+void CreateDBClusterRequest::setChargeType(const std::string &chargeType) {
+  chargeType_ = chargeType;
+  setParameter(std::string("ChargeType"), chargeType);
+}
+

selectdb/src/model/CreateDBClusterResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/selectdb/model/CreateDBClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Selectdb;
+using namespace AlibabaCloud::Selectdb::Model;
+
+CreateDBClusterResult::CreateDBClusterResult() :
+	ServiceResult()
+{}
+
+CreateDBClusterResult::CreateDBClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDBClusterResult::~CreateDBClusterResult()
+{}
+
+void CreateDBClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["DBInstanceId"].isNull())
+		data_.dBInstanceId = dataNode["DBInstanceId"].asString();
+	if(!dataNode["OrderId"].isNull())
+		data_.orderId = std::stol(dataNode["OrderId"].asString());
+	if(!dataNode["ClusterId"].isNull())
+		data_.clusterId = dataNode["ClusterId"].asString();
+
+}
+
+CreateDBClusterResult::Data CreateDBClusterResult::getData()const
+{
+	return data_;
+}
+

selectdb/src/model/CreateDBInstanceRequest.cc

@@ -0,0 +1,192 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/CreateDBInstanceRequest.h>
+
+using AlibabaCloud::Selectdb::Model::CreateDBInstanceRequest;
+
+CreateDBInstanceRequest::CreateDBInstanceRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "CreateDBInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateDBInstanceRequest::~CreateDBInstanceRequest() {}
+
+long CreateDBInstanceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateDBInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateDBInstanceRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateDBInstanceRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateDBInstanceRequest::getConnectionString() const {
+  return connectionString_;
+}
+
+void CreateDBInstanceRequest::setConnectionString(const std::string &connectionString) {
+  connectionString_ = connectionString;
+  setParameter(std::string("ConnectionString"), connectionString);
+}
+
+std::string CreateDBInstanceRequest::getEngineVersion() const {
+  return engineVersion_;
+}
+
+void CreateDBInstanceRequest::setEngineVersion(const std::string &engineVersion) {
+  engineVersion_ = engineVersion;
+  setParameter(std::string("EngineVersion"), engineVersion);
+}
+
+int CreateDBInstanceRequest::getCacheSize() const {
+  return cacheSize_;
+}
+
+void CreateDBInstanceRequest::setCacheSize(int cacheSize) {
+  cacheSize_ = cacheSize;
+  setParameter(std::string("CacheSize"), std::to_string(cacheSize));
+}
+
+std::string CreateDBInstanceRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateDBInstanceRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setBodyParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CreateDBInstanceRequest::getEngine() const {
+  return engine_;
+}
+
+void CreateDBInstanceRequest::setEngine(const std::string &engine) {
+  engine_ = engine;
+  setParameter(std::string("Engine"), engine);
+}
+
+std::string CreateDBInstanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateDBInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateDBInstanceRequest::getDBInstanceDescription() const {
+  return dBInstanceDescription_;
+}
+
+void CreateDBInstanceRequest::setDBInstanceDescription(const std::string &dBInstanceDescription) {
+  dBInstanceDescription_ = dBInstanceDescription;
+  setParameter(std::string("DBInstanceDescription"), dBInstanceDescription);
+}
+
+std::vector<CreateDBInstanceRequest::Tag> CreateDBInstanceRequest::getTag() const {
+  return tag_;
+}
+
+void CreateDBInstanceRequest::setTag(const std::vector<CreateDBInstanceRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+    setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value);
+    setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key);
+  }
+}
+
+std::string CreateDBInstanceRequest::getPeriod() const {
+  return period_;
+}
+
+void CreateDBInstanceRequest::setPeriod(const std::string &period) {
+  period_ = period;
+  setParameter(std::string("Period"), period);
+}
+
+int CreateDBInstanceRequest::getUsedTime() const {
+  return usedTime_;
+}
+
+void CreateDBInstanceRequest::setUsedTime(int usedTime) {
+  usedTime_ = usedTime;
+  setParameter(std::string("UsedTime"), std::to_string(usedTime));
+}
+
+std::string CreateDBInstanceRequest::getDBInstanceClass() const {
+  return dBInstanceClass_;
+}
+
+void CreateDBInstanceRequest::setDBInstanceClass(const std::string &dBInstanceClass) {
+  dBInstanceClass_ = dBInstanceClass;
+  setParameter(std::string("DBInstanceClass"), dBInstanceClass);
+}
+
+std::string CreateDBInstanceRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateDBInstanceRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CreateDBInstanceRequest::getSecurityIPList() const {
+  return securityIPList_;
+}
+
+void CreateDBInstanceRequest::setSecurityIPList(const std::string &securityIPList) {
+  securityIPList_ = securityIPList;
+  setParameter(std::string("SecurityIPList"), securityIPList);
+}
+
+std::string CreateDBInstanceRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateDBInstanceRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string CreateDBInstanceRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void CreateDBInstanceRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
+std::string CreateDBInstanceRequest::getChargeType() const {
+  return chargeType_;
+}
+
+void CreateDBInstanceRequest::setChargeType(const std::string &chargeType) {
+  chargeType_ = chargeType;
+  setParameter(std::string("ChargeType"), chargeType);
+}
+

selectdb/src/model/CreateDBInstanceResult.cc

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

selectdb/src/model/CreateElasticRuleRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/CreateElasticRuleRequest.h>
+
+using AlibabaCloud::Selectdb::Model::CreateElasticRuleRequest;
+
+CreateElasticRuleRequest::CreateElasticRuleRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "CreateElasticRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateElasticRuleRequest::~CreateElasticRuleRequest() {}
+
+long CreateElasticRuleRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateElasticRuleRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateElasticRuleRequest::getExecutionPeriod() const {
+  return executionPeriod_;
+}
+
+void CreateElasticRuleRequest::setExecutionPeriod(const std::string &executionPeriod) {
+  executionPeriod_ = executionPeriod;
+  setParameter(std::string("ExecutionPeriod"), executionPeriod);
+}
+
+std::string CreateElasticRuleRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void CreateElasticRuleRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string CreateElasticRuleRequest::getElasticRuleStartTime() const {
+  return elasticRuleStartTime_;
+}
+
+void CreateElasticRuleRequest::setElasticRuleStartTime(const std::string &elasticRuleStartTime) {
+  elasticRuleStartTime_ = elasticRuleStartTime;
+  setParameter(std::string("ElasticRuleStartTime"), elasticRuleStartTime);
+}
+
+std::string CreateElasticRuleRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateElasticRuleRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateElasticRuleRequest::getClusterClass() const {
+  return clusterClass_;
+}
+
+void CreateElasticRuleRequest::setClusterClass(const std::string &clusterClass) {
+  clusterClass_ = clusterClass;
+  setParameter(std::string("ClusterClass"), clusterClass);
+}
+
+std::string CreateElasticRuleRequest::getDbInstanceId() const {
+  return dbInstanceId_;
+}
+
+void CreateElasticRuleRequest::setDbInstanceId(const std::string &dbInstanceId) {
+  dbInstanceId_ = dbInstanceId;
+  setParameter(std::string("DbInstanceId"), dbInstanceId);
+}
+

selectdb/src/model/CreateElasticRuleResult.cc

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

selectdb/src/model/CreateServiceLinkedRoleForSelectDBRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/CreateServiceLinkedRoleForSelectDBRequest.h>
+
+using AlibabaCloud::Selectdb::Model::CreateServiceLinkedRoleForSelectDBRequest;
+
+CreateServiceLinkedRoleForSelectDBRequest::CreateServiceLinkedRoleForSelectDBRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "CreateServiceLinkedRoleForSelectDB") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateServiceLinkedRoleForSelectDBRequest::~CreateServiceLinkedRoleForSelectDBRequest() {}
+
+long CreateServiceLinkedRoleForSelectDBRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateServiceLinkedRoleForSelectDBRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateServiceLinkedRoleForSelectDBRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateServiceLinkedRoleForSelectDBRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+

selectdb/src/model/CreateServiceLinkedRoleForSelectDBResult.cc

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

selectdb/src/model/DeleteDBClusterRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/DeleteDBClusterRequest.h>
+
+using AlibabaCloud::Selectdb::Model::DeleteDBClusterRequest;
+
+DeleteDBClusterRequest::DeleteDBClusterRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "DeleteDBCluster") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDBClusterRequest::~DeleteDBClusterRequest() {}
+
+long DeleteDBClusterRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteDBClusterRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteDBClusterRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DeleteDBClusterRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DeleteDBClusterRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void DeleteDBClusterRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setBodyParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string DeleteDBClusterRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteDBClusterRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteDBClusterRequest::getDBInstanceId() const {
+  return dBInstanceId_;
+}
+
+void DeleteDBClusterRequest::setDBInstanceId(const std::string &dBInstanceId) {
+  dBInstanceId_ = dBInstanceId;
+  setBodyParameter(std::string("DBInstanceId"), dBInstanceId);
+}
+

selectdb/src/model/DeleteDBClusterResult.cc

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

selectdb/src/model/DeleteDBInstanceRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/DeleteDBInstanceRequest.h>
+
+using AlibabaCloud::Selectdb::Model::DeleteDBInstanceRequest;
+
+DeleteDBInstanceRequest::DeleteDBInstanceRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "DeleteDBInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDBInstanceRequest::~DeleteDBInstanceRequest() {}
+
+long DeleteDBInstanceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteDBInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteDBInstanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteDBInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteDBInstanceRequest::getDBInstanceId() const {
+  return dBInstanceId_;
+}
+
+void DeleteDBInstanceRequest::setDBInstanceId(const std::string &dBInstanceId) {
+  dBInstanceId_ = dBInstanceId;
+  setBodyParameter(std::string("DBInstanceId"), dBInstanceId);
+}
+

selectdb/src/model/DeleteDBInstanceResult.cc

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

selectdb/src/model/DeleteElasticRuleRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/selectdb/model/DeleteElasticRuleRequest.h>
+
+using AlibabaCloud::Selectdb::Model::DeleteElasticRuleRequest;
+
+DeleteElasticRuleRequest::DeleteElasticRuleRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "DeleteElasticRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteElasticRuleRequest::~DeleteElasticRuleRequest() {}
+
+long DeleteElasticRuleRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteElasticRuleRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteElasticRuleRequest::getProduct() const {
+  return product_;
+}
+
+void DeleteElasticRuleRequest::setProduct(const std::string &product) {
+  product_ = product;
+  setParameter(std::string("Product"), product);
+}
+
+std::string DeleteElasticRuleRequest::getClusterId() const {
+  return clusterId_;
+}
+
+void DeleteElasticRuleRequest::setClusterId(const std::string &clusterId) {
+  clusterId_ = clusterId;
+  setParameter(std::string("ClusterId"), clusterId);
+}
+
+std::string DeleteElasticRuleRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteElasticRuleRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeleteElasticRuleRequest::getDbInstanceId() const {
+  return dbInstanceId_;
+}
+
+void DeleteElasticRuleRequest::setDbInstanceId(const std::string &dbInstanceId) {
+  dbInstanceId_ = dbInstanceId;
+  setParameter(std::string("DbInstanceId"), dbInstanceId);
+}
+
+long DeleteElasticRuleRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void DeleteElasticRuleRequest::setRuleId(long ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), std::to_string(ruleId));
+}
+

selectdb/src/model/DeleteElasticRuleResult.cc

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

selectdb/src/model/DescribeAllDBInstanceClassRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/DescribeAllDBInstanceClassRequest.h>
+
+using AlibabaCloud::Selectdb::Model::DescribeAllDBInstanceClassRequest;
+
+DescribeAllDBInstanceClassRequest::DescribeAllDBInstanceClassRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "DescribeAllDBInstanceClass") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeAllDBInstanceClassRequest::~DescribeAllDBInstanceClassRequest() {}
+
+long DescribeAllDBInstanceClassRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeAllDBInstanceClassRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeAllDBInstanceClassRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeAllDBInstanceClassRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

selectdb/src/model/DescribeAllDBInstanceClassResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/selectdb/model/DescribeAllDBInstanceClassResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Selectdb;
+using namespace AlibabaCloud::Selectdb::Model;
+
+DescribeAllDBInstanceClassResult::DescribeAllDBInstanceClassResult() :
+	ServiceResult()
+{}
+
+DescribeAllDBInstanceClassResult::DescribeAllDBInstanceClassResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAllDBInstanceClassResult::~DescribeAllDBInstanceClassResult()
+{}
+
+void DescribeAllDBInstanceClassResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allClassCodeListNode = value["ClassCodeList"]["classCodeListItem"];
+	for (auto valueClassCodeListclassCodeListItem : allClassCodeListNode)
+	{
+		ClassCodeListItem classCodeListObject;
+		if(!valueClassCodeListclassCodeListItem["ClassCode"].isNull())
+			classCodeListObject.classCode = valueClassCodeListclassCodeListItem["ClassCode"].asString();
+		if(!valueClassCodeListclassCodeListItem["CpuCores"].isNull())
+			classCodeListObject.cpuCores = std::stol(valueClassCodeListclassCodeListItem["CpuCores"].asString());
+		if(!valueClassCodeListclassCodeListItem["MemoryInGB"].isNull())
+			classCodeListObject.memoryInGB = std::stol(valueClassCodeListclassCodeListItem["MemoryInGB"].asString());
+		if(!valueClassCodeListclassCodeListItem["DefaultStorageInGB"].isNull())
+			classCodeListObject.defaultStorageInGB = std::stol(valueClassCodeListclassCodeListItem["DefaultStorageInGB"].asString());
+		if(!valueClassCodeListclassCodeListItem["MinStorageInGB"].isNull())
+			classCodeListObject.minStorageInGB = std::stol(valueClassCodeListclassCodeListItem["MinStorageInGB"].asString());
+		if(!valueClassCodeListclassCodeListItem["MaxStorageInGB"].isNull())
+			classCodeListObject.maxStorageInGB = std::stol(valueClassCodeListclassCodeListItem["MaxStorageInGB"].asString());
+		if(!valueClassCodeListclassCodeListItem["StepStorageInGB"].isNull())
+			classCodeListObject.stepStorageInGB = std::stol(valueClassCodeListclassCodeListItem["StepStorageInGB"].asString());
+		classCodeList_.push_back(classCodeListObject);
+	}
+
+}
+
+std::vector<DescribeAllDBInstanceClassResult::ClassCodeListItem> DescribeAllDBInstanceClassResult::getClassCodeList()const
+{
+	return classCodeList_;
+}
+

selectdb/src/model/DescribeDBClusterConfigChangeLogsRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/selectdb/model/DescribeDBClusterConfigChangeLogsRequest.h>
+
+using AlibabaCloud::Selectdb::Model::DescribeDBClusterConfigChangeLogsRequest;
+
+DescribeDBClusterConfigChangeLogsRequest::DescribeDBClusterConfigChangeLogsRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "DescribeDBClusterConfigChangeLogs") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBClusterConfigChangeLogsRequest::~DescribeDBClusterConfigChangeLogsRequest() {}
+
+std::string DescribeDBClusterConfigChangeLogsRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeDBClusterConfigChangeLogsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeDBClusterConfigChangeLogsRequest::getConfigKey() const {
+  return configKey_;
+}
+
+void DescribeDBClusterConfigChangeLogsRequest::setConfigKey(const std::string &configKey) {
+  configKey_ = configKey;
+  setParameter(std::string("ConfigKey"), configKey);
+}
+
+std::string DescribeDBClusterConfigChangeLogsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDBClusterConfigChangeLogsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDBClusterConfigChangeLogsRequest::getDBInstanceId() const {
+  return dBInstanceId_;
+}
+
+void DescribeDBClusterConfigChangeLogsRequest::setDBInstanceId(const std::string &dBInstanceId) {
+  dBInstanceId_ = dBInstanceId;
+  setParameter(std::string("DBInstanceId"), dBInstanceId);
+}
+
+std::string DescribeDBClusterConfigChangeLogsRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeDBClusterConfigChangeLogsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeDBClusterConfigChangeLogsRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeDBClusterConfigChangeLogsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+

selectdb/src/model/DescribeDBClusterConfigChangeLogsResult.cc

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/DescribeDBClusterConfigChangeLogsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Selectdb;
+using namespace AlibabaCloud::Selectdb::Model;
+
+DescribeDBClusterConfigChangeLogsResult::DescribeDBClusterConfigChangeLogsResult() :
+	ServiceResult()
+{}
+
+DescribeDBClusterConfigChangeLogsResult::DescribeDBClusterConfigChangeLogsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBClusterConfigChangeLogsResult::~DescribeDBClusterConfigChangeLogsResult()
+{}
+
+void DescribeDBClusterConfigChangeLogsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["DbInstanceName"].isNull())
+		data_.dbInstanceName = dataNode["DbInstanceName"].asString();
+	if(!dataNode["DbInstanceId"].isNull())
+		data_.dbInstanceId = dataNode["DbInstanceId"].asString();
+	if(!dataNode["DbClusterId"].isNull())
+		data_.dbClusterId = dataNode["DbClusterId"].asString();
+	if(!dataNode["TaskId"].isNull())
+		data_.taskId = std::stoi(dataNode["TaskId"].asString());
+	auto allParamChangeLogsNode = dataNode["ParamChangeLogs"]["ParamChangeLog"];
+	for (auto dataNodeParamChangeLogsParamChangeLog : allParamChangeLogsNode)
+	{
+		Data::ParamChangeLog paramChangeLogObject;
+		if(!dataNodeParamChangeLogsParamChangeLog["Id"].isNull())
+			paramChangeLogObject.id = std::stol(dataNodeParamChangeLogsParamChangeLog["Id"].asString());
+		if(!dataNodeParamChangeLogsParamChangeLog["Name"].isNull())
+			paramChangeLogObject.name = dataNodeParamChangeLogsParamChangeLog["Name"].asString();
+		if(!dataNodeParamChangeLogsParamChangeLog["OldValue"].isNull())
+			paramChangeLogObject.oldValue = dataNodeParamChangeLogsParamChangeLog["OldValue"].asString();
+		if(!dataNodeParamChangeLogsParamChangeLog["NewValue"].isNull())
+			paramChangeLogObject.newValue = dataNodeParamChangeLogsParamChangeLog["NewValue"].asString();
+		if(!dataNodeParamChangeLogsParamChangeLog["IsApplied"].isNull())
+			paramChangeLogObject.isApplied = dataNodeParamChangeLogsParamChangeLog["IsApplied"].asString() == "true";
+		if(!dataNodeParamChangeLogsParamChangeLog["GmtCreated"].isNull())
+			paramChangeLogObject.gmtCreated = dataNodeParamChangeLogsParamChangeLog["GmtCreated"].asString();
+		if(!dataNodeParamChangeLogsParamChangeLog["GmtModified"].isNull())
+			paramChangeLogObject.gmtModified = dataNodeParamChangeLogsParamChangeLog["GmtModified"].asString();
+		data_.paramChangeLogs.push_back(paramChangeLogObject);
+	}
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["AccessDeniedDetail"].isNull())
+		accessDeniedDetail_ = value["AccessDeniedDetail"].asString();
+
+}
+
+std::string DescribeDBClusterConfigChangeLogsResult::getAccessDeniedDetail()const
+{
+	return accessDeniedDetail_;
+}
+
+DescribeDBClusterConfigChangeLogsResult::Data DescribeDBClusterConfigChangeLogsResult::getData()const
+{
+	return data_;
+}
+
+std::string DescribeDBClusterConfigChangeLogsResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string DescribeDBClusterConfigChangeLogsResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+

selectdb/src/model/DescribeDBClusterConfigRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/selectdb/model/DescribeDBClusterConfigRequest.h>
+
+using AlibabaCloud::Selectdb::Model::DescribeDBClusterConfigRequest;
+
+DescribeDBClusterConfigRequest::DescribeDBClusterConfigRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "DescribeDBClusterConfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBClusterConfigRequest::~DescribeDBClusterConfigRequest() {}
+
+std::string DescribeDBClusterConfigRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeDBClusterConfigRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeDBClusterConfigRequest::getConfigKey() const {
+  return configKey_;
+}
+
+void DescribeDBClusterConfigRequest::setConfigKey(const std::string &configKey) {
+  configKey_ = configKey;
+  setParameter(std::string("ConfigKey"), configKey);
+}
+
+std::string DescribeDBClusterConfigRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDBClusterConfigRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDBClusterConfigRequest::getDBInstanceId() const {
+  return dBInstanceId_;
+}
+
+void DescribeDBClusterConfigRequest::setDBInstanceId(const std::string &dBInstanceId) {
+  dBInstanceId_ = dBInstanceId;
+  setParameter(std::string("DBInstanceId"), dBInstanceId);
+}
+

selectdb/src/model/DescribeDBClusterConfigResult.cc

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/DescribeDBClusterConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Selectdb;
+using namespace AlibabaCloud::Selectdb::Model;
+
+DescribeDBClusterConfigResult::DescribeDBClusterConfigResult() :
+	ServiceResult()
+{}
+
+DescribeDBClusterConfigResult::DescribeDBClusterConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBClusterConfigResult::~DescribeDBClusterConfigResult()
+{}
+
+void DescribeDBClusterConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["DbInstanceName"].isNull())
+		data_.dbInstanceName = dataNode["DbInstanceName"].asString();
+	if(!dataNode["DbInstanceId"].isNull())
+		data_.dbInstanceId = dataNode["DbInstanceId"].asString();
+	if(!dataNode["DbClusterId"].isNull())
+		data_.dbClusterId = dataNode["DbClusterId"].asString();
+	if(!dataNode["TaskId"].isNull())
+		data_.taskId = std::stoi(dataNode["TaskId"].asString());
+	auto allParamsNode = dataNode["Params"]["Param"];
+	for (auto dataNodeParamsParam : allParamsNode)
+	{
+		Data::Param paramObject;
+		if(!dataNodeParamsParam["Name"].isNull())
+			paramObject.name = dataNodeParamsParam["Name"].asString();
+		if(!dataNodeParamsParam["Optional"].isNull())
+			paramObject.optional = dataNodeParamsParam["Optional"].asString();
+		if(!dataNodeParamsParam["Comment"].isNull())
+			paramObject.comment = dataNodeParamsParam["Comment"].asString();
+		if(!dataNodeParamsParam["Value"].isNull())
+			paramObject.value = dataNodeParamsParam["Value"].asString();
+		if(!dataNodeParamsParam["ParamCategory"].isNull())
+			paramObject.paramCategory = dataNodeParamsParam["ParamCategory"].asString();
+		if(!dataNodeParamsParam["DefaultValue"].isNull())
+			paramObject.defaultValue = dataNodeParamsParam["DefaultValue"].asString();
+		if(!dataNodeParamsParam["IsDynamic"].isNull())
+			paramObject.isDynamic = std::stoi(dataNodeParamsParam["IsDynamic"].asString());
+		if(!dataNodeParamsParam["IsUserModifiable"].isNull())
+			paramObject.isUserModifiable = std::stoi(dataNodeParamsParam["IsUserModifiable"].asString());
+		data_.params.push_back(paramObject);
+	}
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["AccessDeniedDetail"].isNull())
+		accessDeniedDetail_ = value["AccessDeniedDetail"].asString();
+
+}
+
+std::string DescribeDBClusterConfigResult::getAccessDeniedDetail()const
+{
+	return accessDeniedDetail_;
+}
+
+DescribeDBClusterConfigResult::Data DescribeDBClusterConfigResult::getData()const
+{
+	return data_;
+}
+
+std::string DescribeDBClusterConfigResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string DescribeDBClusterConfigResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+

selectdb/src/model/DescribeDBInstanceAttributeRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/DescribeDBInstanceAttributeRequest.h>
+
+using AlibabaCloud::Selectdb::Model::DescribeDBInstanceAttributeRequest;
+
+DescribeDBInstanceAttributeRequest::DescribeDBInstanceAttributeRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "DescribeDBInstanceAttribute") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBInstanceAttributeRequest::~DescribeDBInstanceAttributeRequest() {}
+
+long DescribeDBInstanceAttributeRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeDBInstanceAttributeRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDBInstanceAttributeRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDBInstanceAttributeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDBInstanceAttributeRequest::getDBInstanceId() const {
+  return dBInstanceId_;
+}
+
+void DescribeDBInstanceAttributeRequest::setDBInstanceId(const std::string &dBInstanceId) {
+  dBInstanceId_ = dBInstanceId;
+  setParameter(std::string("DBInstanceId"), dBInstanceId);
+}
+

selectdb/src/model/DescribeDBInstanceAttributeResult.cc

@@ -0,0 +1,262 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/DescribeDBInstanceAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Selectdb;
+using namespace AlibabaCloud::Selectdb::Model;
+
+DescribeDBInstanceAttributeResult::DescribeDBInstanceAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeDBInstanceAttributeResult::DescribeDBInstanceAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBInstanceAttributeResult::~DescribeDBInstanceAttributeResult()
+{}
+
+void DescribeDBInstanceAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDBClusterListNode = value["DBClusterList"]["DbClusterListItem"];
+	for (auto valueDBClusterListDbClusterListItem : allDBClusterListNode)
+	{
+		DbClusterListItem dBClusterListObject;
+		if(!valueDBClusterListDbClusterListItem["DbInstanceName"].isNull())
+			dBClusterListObject.dbInstanceName = valueDBClusterListDbClusterListItem["DbInstanceName"].asString();
+		if(!valueDBClusterListDbClusterListItem["DbClusterId"].isNull())
+			dBClusterListObject.dbClusterId = valueDBClusterListDbClusterListItem["DbClusterId"].asString();
+		if(!valueDBClusterListDbClusterListItem["DbClusterName"].isNull())
+			dBClusterListObject.dbClusterName = valueDBClusterListDbClusterListItem["DbClusterName"].asString();
+		if(!valueDBClusterListDbClusterListItem["Status"].isNull())
+			dBClusterListObject.status = valueDBClusterListDbClusterListItem["Status"].asString();
+		if(!valueDBClusterListDbClusterListItem["CreatedTime"].isNull())
+			dBClusterListObject.createdTime = valueDBClusterListDbClusterListItem["CreatedTime"].asString();
+		if(!valueDBClusterListDbClusterListItem["DbClusterClass"].isNull())
+			dBClusterListObject.dbClusterClass = valueDBClusterListDbClusterListItem["DbClusterClass"].asString();
+		if(!valueDBClusterListDbClusterListItem["CpuCores"].isNull())
+			dBClusterListObject.cpuCores = std::stol(valueDBClusterListDbClusterListItem["CpuCores"].asString());
+		if(!valueDBClusterListDbClusterListItem["Memory"].isNull())
+			dBClusterListObject.memory = std::stol(valueDBClusterListDbClusterListItem["Memory"].asString());
+		if(!valueDBClusterListDbClusterListItem["CacheStorageType"].isNull())
+			dBClusterListObject.cacheStorageType = valueDBClusterListDbClusterListItem["CacheStorageType"].asString();
+		if(!valueDBClusterListDbClusterListItem["PerformanceLevel"].isNull())
+			dBClusterListObject.performanceLevel = valueDBClusterListDbClusterListItem["PerformanceLevel"].asString();
+		if(!valueDBClusterListDbClusterListItem["CacheStorageSizeGB"].isNull())
+			dBClusterListObject.cacheStorageSizeGB = valueDBClusterListDbClusterListItem["CacheStorageSizeGB"].asString();
+		if(!valueDBClusterListDbClusterListItem["StartTime"].isNull())
+			dBClusterListObject.startTime = valueDBClusterListDbClusterListItem["StartTime"].asString();
+		if(!valueDBClusterListDbClusterListItem["ChargeType"].isNull())
+			dBClusterListObject.chargeType = valueDBClusterListDbClusterListItem["ChargeType"].asString();
+		if(!valueDBClusterListDbClusterListItem["ModifiedTime"].isNull())
+			dBClusterListObject.modifiedTime = valueDBClusterListDbClusterListItem["ModifiedTime"].asString();
+		if(!valueDBClusterListDbClusterListItem["ScalingRulesEnable"].isNull())
+			dBClusterListObject.scalingRulesEnable = valueDBClusterListDbClusterListItem["ScalingRulesEnable"].asString() == "true";
+		dBClusterList_.push_back(dBClusterListObject);
+	}
+	auto allTagsNode = value["Tags"]["TagsItem"];
+	for (auto valueTagsTagsItem : allTagsNode)
+	{
+		TagsItem tagsObject;
+		if(!valueTagsTagsItem["TagKey"].isNull())
+			tagsObject.tagKey = valueTagsTagsItem["TagKey"].asString();
+		if(!valueTagsTagsItem["TagValue"].isNull())
+			tagsObject.tagValue = valueTagsTagsItem["TagValue"].asString();
+		tags_.push_back(tagsObject);
+	}
+	auto allCanUpgradeVersions = value["CanUpgradeVersions"]["canUpgradeCanUpgradeVersionsVersions"];
+	for (const auto &item : allCanUpgradeVersions)
+		canUpgradeVersions_.push_back(item.asString());
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["SubDomain"].isNull())
+		subDomain_ = value["SubDomain"].asString();
+	if(!value["GmtModified"].isNull())
+		gmtModified_ = value["GmtModified"].asString();
+	if(!value["LockMode"].isNull())
+		lockMode_ = std::stol(value["LockMode"].asString());
+	if(!value["LockReason"].isNull())
+		lockReason_ = value["LockReason"].asString();
+	if(!value["ResourceCpu"].isNull())
+		resourceCpu_ = std::stol(value["ResourceCpu"].asString());
+	if(!value["StorageSize"].isNull())
+		storageSize_ = std::stol(value["StorageSize"].asString());
+	if(!value["ObjectStoreSize"].isNull())
+		objectStoreSize_ = std::stol(value["ObjectStoreSize"].asString());
+	if(!value["MaintainStarttime"].isNull())
+		maintainStarttime_ = value["MaintainStarttime"].asString();
+	if(!value["MaintainEndtime"].isNull())
+		maintainEndtime_ = value["MaintainEndtime"].asString();
+	if(!value["Engine"].isNull())
+		engine_ = value["Engine"].asString();
+	if(!value["EngineVersion"].isNull())
+		engineVersion_ = value["EngineVersion"].asString();
+	if(!value["EngineMinorVersion"].isNull())
+		engineMinorVersion_ = value["EngineMinorVersion"].asString();
+	if(!value["DBInstanceId"].isNull())
+		dBInstanceId_ = value["DBInstanceId"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["ChargeType"].isNull())
+		chargeType_ = value["ChargeType"].asString();
+	if(!value["ExpireTime"].isNull())
+		expireTime_ = value["ExpireTime"].asString();
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["ZoneId"].isNull())
+		zoneId_ = value["ZoneId"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+
+}
+
+std::string DescribeDBInstanceAttributeResult::getEngineMinorVersion()const
+{
+	return engineMinorVersion_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getDescription()const
+{
+	return description_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getGmtModified()const
+{
+	return gmtModified_;
+}
+
+std::vector<std::string> DescribeDBInstanceAttributeResult::getCanUpgradeVersions()const
+{
+	return canUpgradeVersions_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getMaintainStarttime()const
+{
+	return maintainStarttime_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getSubDomain()const
+{
+	return subDomain_;
+}
+
+long DescribeDBInstanceAttributeResult::getObjectStoreSize()const
+{
+	return objectStoreSize_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getLockReason()const
+{
+	return lockReason_;
+}
+
+std::vector<DescribeDBInstanceAttributeResult::TagsItem> DescribeDBInstanceAttributeResult::getTags()const
+{
+	return tags_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getEngine()const
+{
+	return engine_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getMaintainEndtime()const
+{
+	return maintainEndtime_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+long DescribeDBInstanceAttributeResult::getResourceCpu()const
+{
+	return resourceCpu_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getZoneId()const
+{
+	return zoneId_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+long DescribeDBInstanceAttributeResult::getStorageSize()const
+{
+	return storageSize_;
+}
+
+long DescribeDBInstanceAttributeResult::getLockMode()const
+{
+	return lockMode_;
+}
+
+std::vector<DescribeDBInstanceAttributeResult::DbClusterListItem> DescribeDBInstanceAttributeResult::getDBClusterList()const
+{
+	return dBClusterList_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getChargeType()const
+{
+	return chargeType_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string DescribeDBInstanceAttributeResult::getExpireTime()const
+{
+	return expireTime_;
+}
+

selectdb/src/model/DescribeDBInstanceNetInfoRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/selectdb/model/DescribeDBInstanceNetInfoRequest.h>
+
+using AlibabaCloud::Selectdb::Model::DescribeDBInstanceNetInfoRequest;
+
+DescribeDBInstanceNetInfoRequest::DescribeDBInstanceNetInfoRequest()
+    : RpcServiceRequest("selectdb", "2023-05-22", "DescribeDBInstanceNetInfo") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBInstanceNetInfoRequest::~DescribeDBInstanceNetInfoRequest() {}
+
+long DescribeDBInstanceNetInfoRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeDBInstanceNetInfoRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDBInstanceNetInfoRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDBInstanceNetInfoRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDBInstanceNetInfoRequest::getDBInstanceId() const {
+  return dBInstanceId_;
+}
+
+void DescribeDBInstanceNetInfoRequest::setDBInstanceId(const std::string &dBInstanceId) {
+  dBInstanceId_ = dBInstanceId;
+  setParameter(std::string("DBInstanceId"), dBInstanceId);
+}
+