Generated 2019-01-01 for HBase.

CHANGELOG

@@ -1,3 +1,6 @@
+2019-11-20 Version 1.36.185
+- Generated 2019-01-01 for `HBase`.
+
 2019-11-20 Version 1.36.184
 - Add API ReportVoipProblems.
 - Add API QueryVoipNumberBindINfos.

VERSION

@@ -1 +1 @@
-1.36.184
+1.36.185

hbase/CMakeLists.txt

@@ -0,0 +1,166 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(hbase_public_header 
+	include/alibabacloud/hbase/HBaseClient.h
+	include/alibabacloud/hbase/HBaseExport.h )
+
+set(hbase_public_header_model 
+	include/alibabacloud/hbase/model/AddUserHdfsInfoRequest.h
+	include/alibabacloud/hbase/model/AddUserHdfsInfoResult.h
+	include/alibabacloud/hbase/model/ConvertInstanceRequest.h
+	include/alibabacloud/hbase/model/ConvertInstanceResult.h
+	include/alibabacloud/hbase/model/CreateInstanceRequest.h
+	include/alibabacloud/hbase/model/CreateInstanceResult.h
+	include/alibabacloud/hbase/model/DeleteInstanceRequest.h
+	include/alibabacloud/hbase/model/DeleteInstanceResult.h
+	include/alibabacloud/hbase/model/DeleteUserHdfsInfoRequest.h
+	include/alibabacloud/hbase/model/DeleteUserHdfsInfoResult.h
+	include/alibabacloud/hbase/model/DescribeEndpointsRequest.h
+	include/alibabacloud/hbase/model/DescribeEndpointsResult.h
+	include/alibabacloud/hbase/model/DescribeInstanceRequest.h
+	include/alibabacloud/hbase/model/DescribeInstanceResult.h
+	include/alibabacloud/hbase/model/DescribeInstancesRequest.h
+	include/alibabacloud/hbase/model/DescribeInstancesResult.h
+	include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.h
+	include/alibabacloud/hbase/model/DescribeIpWhitelistResult.h
+	include/alibabacloud/hbase/model/DescribeRegionsRequest.h
+	include/alibabacloud/hbase/model/DescribeRegionsResult.h
+	include/alibabacloud/hbase/model/DescribeSecurityGroupsRequest.h
+	include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.h
+	include/alibabacloud/hbase/model/ModifyInstanceNameRequest.h
+	include/alibabacloud/hbase/model/ModifyInstanceNameResult.h
+	include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.h
+	include/alibabacloud/hbase/model/ModifyIpWhitelistResult.h
+	include/alibabacloud/hbase/model/ModifySecurityGroupsRequest.h
+	include/alibabacloud/hbase/model/ModifySecurityGroupsResult.h
+	include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.h
+	include/alibabacloud/hbase/model/ModifyUIAccountPasswordResult.h
+	include/alibabacloud/hbase/model/QueryXpackRelateDBRequest.h
+	include/alibabacloud/hbase/model/QueryXpackRelateDBResult.h
+	include/alibabacloud/hbase/model/RenewInstanceRequest.h
+	include/alibabacloud/hbase/model/RenewInstanceResult.h
+	include/alibabacloud/hbase/model/ResizeDiskSizeRequest.h
+	include/alibabacloud/hbase/model/ResizeDiskSizeResult.h
+	include/alibabacloud/hbase/model/ResizeNodeCountRequest.h
+	include/alibabacloud/hbase/model/ResizeNodeCountResult.h
+	include/alibabacloud/hbase/model/RestartInstanceRequest.h
+	include/alibabacloud/hbase/model/RestartInstanceResult.h
+	include/alibabacloud/hbase/model/XpackRelateDBRequest.h
+	include/alibabacloud/hbase/model/XpackRelateDBResult.h )
+
+set(hbase_src 
+	src/HBaseClient.cc
+	src/model/AddUserHdfsInfoRequest.cc
+	src/model/AddUserHdfsInfoResult.cc
+	src/model/ConvertInstanceRequest.cc
+	src/model/ConvertInstanceResult.cc
+	src/model/CreateInstanceRequest.cc
+	src/model/CreateInstanceResult.cc
+	src/model/DeleteInstanceRequest.cc
+	src/model/DeleteInstanceResult.cc
+	src/model/DeleteUserHdfsInfoRequest.cc
+	src/model/DeleteUserHdfsInfoResult.cc
+	src/model/DescribeEndpointsRequest.cc
+	src/model/DescribeEndpointsResult.cc
+	src/model/DescribeInstanceRequest.cc
+	src/model/DescribeInstanceResult.cc
+	src/model/DescribeInstancesRequest.cc
+	src/model/DescribeInstancesResult.cc
+	src/model/DescribeIpWhitelistRequest.cc
+	src/model/DescribeIpWhitelistResult.cc
+	src/model/DescribeRegionsRequest.cc
+	src/model/DescribeRegionsResult.cc
+	src/model/DescribeSecurityGroupsRequest.cc
+	src/model/DescribeSecurityGroupsResult.cc
+	src/model/ModifyInstanceNameRequest.cc
+	src/model/ModifyInstanceNameResult.cc
+	src/model/ModifyIpWhitelistRequest.cc
+	src/model/ModifyIpWhitelistResult.cc
+	src/model/ModifySecurityGroupsRequest.cc
+	src/model/ModifySecurityGroupsResult.cc
+	src/model/ModifyUIAccountPasswordRequest.cc
+	src/model/ModifyUIAccountPasswordResult.cc
+	src/model/QueryXpackRelateDBRequest.cc
+	src/model/QueryXpackRelateDBResult.cc
+	src/model/RenewInstanceRequest.cc
+	src/model/RenewInstanceResult.cc
+	src/model/ResizeDiskSizeRequest.cc
+	src/model/ResizeDiskSizeResult.cc
+	src/model/ResizeNodeCountRequest.cc
+	src/model/ResizeNodeCountResult.cc
+	src/model/RestartInstanceRequest.cc
+	src/model/RestartInstanceResult.cc
+	src/model/XpackRelateDBRequest.cc
+	src/model/XpackRelateDBResult.cc )
+
+add_library(hbase ${LIB_TYPE}
+	${hbase_public_header}
+	${hbase_public_header_model}
+	${hbase_src})
+
+set_target_properties(hbase
+	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}hbase
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(hbase
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_HBASE_LIBRARY)
+endif()
+
+target_include_directories(hbase
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(hbase
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(hbase
+		jsoncpp)
+	target_include_directories(hbase
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(hbase
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(hbase
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(hbase
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(hbase
+		jsoncpp)
+endif()
+
+install(FILES ${hbase_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/hbase)
+install(FILES ${hbase_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/hbase/model)
+install(TARGETS hbase
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

hbase/include/alibabacloud/hbase/HBaseClient.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_HBASECLIENT_H_
+#define ALIBABACLOUD_HBASE_HBASECLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "HBaseExport.h"
+#include "model/AddUserHdfsInfoRequest.h"
+#include "model/AddUserHdfsInfoResult.h"
+#include "model/ConvertInstanceRequest.h"
+#include "model/ConvertInstanceResult.h"
+#include "model/CreateInstanceRequest.h"
+#include "model/CreateInstanceResult.h"
+#include "model/DeleteInstanceRequest.h"
+#include "model/DeleteInstanceResult.h"
+#include "model/DeleteUserHdfsInfoRequest.h"
+#include "model/DeleteUserHdfsInfoResult.h"
+#include "model/DescribeEndpointsRequest.h"
+#include "model/DescribeEndpointsResult.h"
+#include "model/DescribeInstanceRequest.h"
+#include "model/DescribeInstanceResult.h"
+#include "model/DescribeInstancesRequest.h"
+#include "model/DescribeInstancesResult.h"
+#include "model/DescribeIpWhitelistRequest.h"
+#include "model/DescribeIpWhitelistResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/DescribeSecurityGroupsRequest.h"
+#include "model/DescribeSecurityGroupsResult.h"
+#include "model/ModifyInstanceNameRequest.h"
+#include "model/ModifyInstanceNameResult.h"
+#include "model/ModifyIpWhitelistRequest.h"
+#include "model/ModifyIpWhitelistResult.h"
+#include "model/ModifySecurityGroupsRequest.h"
+#include "model/ModifySecurityGroupsResult.h"
+#include "model/ModifyUIAccountPasswordRequest.h"
+#include "model/ModifyUIAccountPasswordResult.h"
+#include "model/QueryXpackRelateDBRequest.h"
+#include "model/QueryXpackRelateDBResult.h"
+#include "model/RenewInstanceRequest.h"
+#include "model/RenewInstanceResult.h"
+#include "model/ResizeDiskSizeRequest.h"
+#include "model/ResizeDiskSizeResult.h"
+#include "model/ResizeNodeCountRequest.h"
+#include "model/ResizeNodeCountResult.h"
+#include "model/RestartInstanceRequest.h"
+#include "model/RestartInstanceResult.h"
+#include "model/XpackRelateDBRequest.h"
+#include "model/XpackRelateDBResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		class ALIBABACLOUD_HBASE_EXPORT HBaseClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AddUserHdfsInfoResult> AddUserHdfsInfoOutcome;
+			typedef std::future<AddUserHdfsInfoOutcome> AddUserHdfsInfoOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::AddUserHdfsInfoRequest&, const AddUserHdfsInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddUserHdfsInfoAsyncHandler;
+			typedef Outcome<Error, Model::ConvertInstanceResult> ConvertInstanceOutcome;
+			typedef std::future<ConvertInstanceOutcome> ConvertInstanceOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ConvertInstanceRequest&, const ConvertInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConvertInstanceAsyncHandler;
+			typedef Outcome<Error, Model::CreateInstanceResult> CreateInstanceOutcome;
+			typedef std::future<CreateInstanceOutcome> CreateInstanceOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::CreateInstanceRequest&, const CreateInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteInstanceResult> DeleteInstanceOutcome;
+			typedef std::future<DeleteInstanceOutcome> DeleteInstanceOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DeleteInstanceRequest&, const DeleteInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteUserHdfsInfoResult> DeleteUserHdfsInfoOutcome;
+			typedef std::future<DeleteUserHdfsInfoOutcome> DeleteUserHdfsInfoOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DeleteUserHdfsInfoRequest&, const DeleteUserHdfsInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUserHdfsInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeEndpointsResult> DescribeEndpointsOutcome;
+			typedef std::future<DescribeEndpointsOutcome> DescribeEndpointsOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeEndpointsRequest&, const DescribeEndpointsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEndpointsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeInstanceResult> DescribeInstanceOutcome;
+			typedef std::future<DescribeInstanceOutcome> DescribeInstanceOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeInstanceRequest&, const DescribeInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeInstancesResult> DescribeInstancesOutcome;
+			typedef std::future<DescribeInstancesOutcome> DescribeInstancesOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeInstancesRequest&, const DescribeInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstancesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeIpWhitelistResult> DescribeIpWhitelistOutcome;
+			typedef std::future<DescribeIpWhitelistOutcome> DescribeIpWhitelistOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeIpWhitelistRequest&, const DescribeIpWhitelistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeIpWhitelistAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSecurityGroupsResult> DescribeSecurityGroupsOutcome;
+			typedef std::future<DescribeSecurityGroupsOutcome> DescribeSecurityGroupsOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeSecurityGroupsRequest&, const DescribeSecurityGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecurityGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ModifyInstanceNameResult> ModifyInstanceNameOutcome;
+			typedef std::future<ModifyInstanceNameOutcome> ModifyInstanceNameOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ModifyInstanceNameRequest&, const ModifyInstanceNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceNameAsyncHandler;
+			typedef Outcome<Error, Model::ModifyIpWhitelistResult> ModifyIpWhitelistOutcome;
+			typedef std::future<ModifyIpWhitelistOutcome> ModifyIpWhitelistOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ModifyIpWhitelistRequest&, const ModifyIpWhitelistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyIpWhitelistAsyncHandler;
+			typedef Outcome<Error, Model::ModifySecurityGroupsResult> ModifySecurityGroupsOutcome;
+			typedef std::future<ModifySecurityGroupsOutcome> ModifySecurityGroupsOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ModifySecurityGroupsRequest&, const ModifySecurityGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifySecurityGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ModifyUIAccountPasswordResult> ModifyUIAccountPasswordOutcome;
+			typedef std::future<ModifyUIAccountPasswordOutcome> ModifyUIAccountPasswordOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ModifyUIAccountPasswordRequest&, const ModifyUIAccountPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyUIAccountPasswordAsyncHandler;
+			typedef Outcome<Error, Model::QueryXpackRelateDBResult> QueryXpackRelateDBOutcome;
+			typedef std::future<QueryXpackRelateDBOutcome> QueryXpackRelateDBOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::QueryXpackRelateDBRequest&, const QueryXpackRelateDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryXpackRelateDBAsyncHandler;
+			typedef Outcome<Error, Model::RenewInstanceResult> RenewInstanceOutcome;
+			typedef std::future<RenewInstanceOutcome> RenewInstanceOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::RenewInstanceRequest&, const RenewInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RenewInstanceAsyncHandler;
+			typedef Outcome<Error, Model::ResizeDiskSizeResult> ResizeDiskSizeOutcome;
+			typedef std::future<ResizeDiskSizeOutcome> ResizeDiskSizeOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ResizeDiskSizeRequest&, const ResizeDiskSizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResizeDiskSizeAsyncHandler;
+			typedef Outcome<Error, Model::ResizeNodeCountResult> ResizeNodeCountOutcome;
+			typedef std::future<ResizeNodeCountOutcome> ResizeNodeCountOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ResizeNodeCountRequest&, const ResizeNodeCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResizeNodeCountAsyncHandler;
+			typedef Outcome<Error, Model::RestartInstanceResult> RestartInstanceOutcome;
+			typedef std::future<RestartInstanceOutcome> RestartInstanceOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::RestartInstanceRequest&, const RestartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartInstanceAsyncHandler;
+			typedef Outcome<Error, Model::XpackRelateDBResult> XpackRelateDBOutcome;
+			typedef std::future<XpackRelateDBOutcome> XpackRelateDBOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::XpackRelateDBRequest&, const XpackRelateDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> XpackRelateDBAsyncHandler;
+
+			HBaseClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			HBaseClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			HBaseClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~HBaseClient();
+			AddUserHdfsInfoOutcome addUserHdfsInfo(const Model::AddUserHdfsInfoRequest &request)const;
+			void addUserHdfsInfoAsync(const Model::AddUserHdfsInfoRequest& request, const AddUserHdfsInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddUserHdfsInfoOutcomeCallable addUserHdfsInfoCallable(const Model::AddUserHdfsInfoRequest& request) const;
+			ConvertInstanceOutcome convertInstance(const Model::ConvertInstanceRequest &request)const;
+			void convertInstanceAsync(const Model::ConvertInstanceRequest& request, const ConvertInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ConvertInstanceOutcomeCallable convertInstanceCallable(const Model::ConvertInstanceRequest& request) const;
+			CreateInstanceOutcome createInstance(const Model::CreateInstanceRequest &request)const;
+			void createInstanceAsync(const Model::CreateInstanceRequest& request, const CreateInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateInstanceOutcomeCallable createInstanceCallable(const Model::CreateInstanceRequest& request) const;
+			DeleteInstanceOutcome deleteInstance(const Model::DeleteInstanceRequest &request)const;
+			void deleteInstanceAsync(const Model::DeleteInstanceRequest& request, const DeleteInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteInstanceOutcomeCallable deleteInstanceCallable(const Model::DeleteInstanceRequest& request) const;
+			DeleteUserHdfsInfoOutcome deleteUserHdfsInfo(const Model::DeleteUserHdfsInfoRequest &request)const;
+			void deleteUserHdfsInfoAsync(const Model::DeleteUserHdfsInfoRequest& request, const DeleteUserHdfsInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteUserHdfsInfoOutcomeCallable deleteUserHdfsInfoCallable(const Model::DeleteUserHdfsInfoRequest& request) const;
+			DescribeEndpointsOutcome describeEndpoints(const Model::DescribeEndpointsRequest &request)const;
+			void describeEndpointsAsync(const Model::DescribeEndpointsRequest& request, const DescribeEndpointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeEndpointsOutcomeCallable describeEndpointsCallable(const Model::DescribeEndpointsRequest& request) const;
+			DescribeInstanceOutcome describeInstance(const Model::DescribeInstanceRequest &request)const;
+			void describeInstanceAsync(const Model::DescribeInstanceRequest& request, const DescribeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeInstanceOutcomeCallable describeInstanceCallable(const Model::DescribeInstanceRequest& request) const;
+			DescribeInstancesOutcome describeInstances(const Model::DescribeInstancesRequest &request)const;
+			void describeInstancesAsync(const Model::DescribeInstancesRequest& request, const DescribeInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeInstancesOutcomeCallable describeInstancesCallable(const Model::DescribeInstancesRequest& request) const;
+			DescribeIpWhitelistOutcome describeIpWhitelist(const Model::DescribeIpWhitelistRequest &request)const;
+			void describeIpWhitelistAsync(const Model::DescribeIpWhitelistRequest& request, const DescribeIpWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeIpWhitelistOutcomeCallable describeIpWhitelistCallable(const Model::DescribeIpWhitelistRequest& request) const;
+			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
+			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			DescribeSecurityGroupsOutcome describeSecurityGroups(const Model::DescribeSecurityGroupsRequest &request)const;
+			void describeSecurityGroupsAsync(const Model::DescribeSecurityGroupsRequest& request, const DescribeSecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSecurityGroupsOutcomeCallable describeSecurityGroupsCallable(const Model::DescribeSecurityGroupsRequest& request) const;
+			ModifyInstanceNameOutcome modifyInstanceName(const Model::ModifyInstanceNameRequest &request)const;
+			void modifyInstanceNameAsync(const Model::ModifyInstanceNameRequest& request, const ModifyInstanceNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyInstanceNameOutcomeCallable modifyInstanceNameCallable(const Model::ModifyInstanceNameRequest& request) const;
+			ModifyIpWhitelistOutcome modifyIpWhitelist(const Model::ModifyIpWhitelistRequest &request)const;
+			void modifyIpWhitelistAsync(const Model::ModifyIpWhitelistRequest& request, const ModifyIpWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyIpWhitelistOutcomeCallable modifyIpWhitelistCallable(const Model::ModifyIpWhitelistRequest& request) const;
+			ModifySecurityGroupsOutcome modifySecurityGroups(const Model::ModifySecurityGroupsRequest &request)const;
+			void modifySecurityGroupsAsync(const Model::ModifySecurityGroupsRequest& request, const ModifySecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifySecurityGroupsOutcomeCallable modifySecurityGroupsCallable(const Model::ModifySecurityGroupsRequest& request) const;
+			ModifyUIAccountPasswordOutcome modifyUIAccountPassword(const Model::ModifyUIAccountPasswordRequest &request)const;
+			void modifyUIAccountPasswordAsync(const Model::ModifyUIAccountPasswordRequest& request, const ModifyUIAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyUIAccountPasswordOutcomeCallable modifyUIAccountPasswordCallable(const Model::ModifyUIAccountPasswordRequest& request) const;
+			QueryXpackRelateDBOutcome queryXpackRelateDB(const Model::QueryXpackRelateDBRequest &request)const;
+			void queryXpackRelateDBAsync(const Model::QueryXpackRelateDBRequest& request, const QueryXpackRelateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryXpackRelateDBOutcomeCallable queryXpackRelateDBCallable(const Model::QueryXpackRelateDBRequest& request) const;
+			RenewInstanceOutcome renewInstance(const Model::RenewInstanceRequest &request)const;
+			void renewInstanceAsync(const Model::RenewInstanceRequest& request, const RenewInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RenewInstanceOutcomeCallable renewInstanceCallable(const Model::RenewInstanceRequest& request) const;
+			ResizeDiskSizeOutcome resizeDiskSize(const Model::ResizeDiskSizeRequest &request)const;
+			void resizeDiskSizeAsync(const Model::ResizeDiskSizeRequest& request, const ResizeDiskSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResizeDiskSizeOutcomeCallable resizeDiskSizeCallable(const Model::ResizeDiskSizeRequest& request) const;
+			ResizeNodeCountOutcome resizeNodeCount(const Model::ResizeNodeCountRequest &request)const;
+			void resizeNodeCountAsync(const Model::ResizeNodeCountRequest& request, const ResizeNodeCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResizeNodeCountOutcomeCallable resizeNodeCountCallable(const Model::ResizeNodeCountRequest& request) const;
+			RestartInstanceOutcome restartInstance(const Model::RestartInstanceRequest &request)const;
+			void restartInstanceAsync(const Model::RestartInstanceRequest& request, const RestartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RestartInstanceOutcomeCallable restartInstanceCallable(const Model::RestartInstanceRequest& request) const;
+			XpackRelateDBOutcome xpackRelateDB(const Model::XpackRelateDBRequest &request)const;
+			void xpackRelateDBAsync(const Model::XpackRelateDBRequest& request, const XpackRelateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			XpackRelateDBOutcomeCallable xpackRelateDBCallable(const Model::XpackRelateDBRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_HBASE_HBASECLIENT_H_

hbase/include/alibabacloud/hbase/HBaseExport.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_HBASE_HBASEEXPORT_H_
+#define ALIBABACLOUD_HBASE_HBASEEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_HBASE_LIBRARY)
+#		define ALIBABACLOUD_HBASE_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_HBASE_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_HBASE_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_HBASE_HBASEEXPORT_H_

hbase/include/alibabacloud/hbase/model/AddUserHdfsInfoRequest.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_HBASE_MODEL_ADDUSERHDFSINFOREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_ADDUSERHDFSINFOREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT AddUserHdfsInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddUserHdfsInfoRequest();
+				~AddUserHdfsInfoRequest();
+
+				std::string getExtInfo()const;
+				void setExtInfo(const std::string& extInfo);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string extInfo_;
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_ADDUSERHDFSINFOREQUEST_H_

hbase/include/alibabacloud/hbase/model/AddUserHdfsInfoResult.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_HBASE_MODEL_ADDUSERHDFSINFORESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_ADDUSERHDFSINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT AddUserHdfsInfoResult : public ServiceResult
+			{
+			public:
+
+
+				AddUserHdfsInfoResult();
+				explicit AddUserHdfsInfoResult(const std::string &payload);
+				~AddUserHdfsInfoResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_ADDUSERHDFSINFORESULT_H_

hbase/include/alibabacloud/hbase/model/ConvertInstanceRequest.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_HBASE_MODEL_CONVERTINSTANCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_CONVERTINSTANCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ConvertInstanceRequest : public RpcServiceRequest
+			{
+
+			public:
+				ConvertInstanceRequest();
+				~ConvertInstanceRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getDuration()const;
+				void setDuration(int duration);
+				std::string getPricingCycle()const;
+				void setPricingCycle(const std::string& pricingCycle);
+
+            private:
+				std::string clusterId_;
+				int duration_;
+				std::string pricingCycle_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_CONVERTINSTANCEREQUEST_H_

hbase/include/alibabacloud/hbase/model/ConvertInstanceResult.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_HBASE_MODEL_CONVERTINSTANCERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_CONVERTINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ConvertInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				ConvertInstanceResult();
+				explicit ConvertInstanceResult(const std::string &payload);
+				~ConvertInstanceResult();
+				long getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_CONVERTINSTANCERESULT_H_

hbase/include/alibabacloud/hbase/model/CreateInstanceRequest.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT CreateInstanceRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateInstanceRequest();
+				~CreateInstanceRequest();
+
+				std::string getClusterName()const;
+				void setClusterName(const std::string& clusterName);
+				std::string getDbInstanceConnType()const;
+				void setDbInstanceConnType(const std::string& dbInstanceConnType);
+				std::string getEngineVersion()const;
+				void setEngineVersion(const std::string& engineVersion);
+				std::string getDepMode()const;
+				void setDepMode(const std::string& depMode);
+				std::string getBackupId()const;
+				void setBackupId(const std::string& backupId);
+				std::string getDbInstanceType()const;
+				void setDbInstanceType(const std::string& dbInstanceType);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
+				std::string getSecurityIPList()const;
+				void setSecurityIPList(const std::string& securityIPList);
+				std::string getAutoRenew()const;
+				void setAutoRenew(const std::string& autoRenew);
+				std::string getNetType()const;
+				void setNetType(const std::string& netType);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+				std::string getCoreDiskType()const;
+				void setCoreDiskType(const std::string& coreDiskType);
+				std::string getPricingCycle()const;
+				void setPricingCycle(const std::string& pricingCycle);
+				std::string getCoreInstanceQuantity()const;
+				void setCoreInstanceQuantity(const std::string& coreInstanceQuantity);
+				std::string getDuration()const;
+				void setDuration(const std::string& duration);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getEngine()const;
+				void setEngine(const std::string& engine);
+				std::string getRestoreTime()const;
+				void setRestoreTime(const std::string& restoreTime);
+				std::string getSrcDBInstanceId()const;
+				void setSrcDBInstanceId(const std::string& srcDBInstanceId);
+				std::string getMasterInstanceType()const;
+				void setMasterInstanceType(const std::string& masterInstanceType);
+				std::string getColdStorageSize()const;
+				void setColdStorageSize(const std::string& coldStorageSize);
+				std::string getCoreDiskQuantity()const;
+				void setCoreDiskQuantity(const std::string& coreDiskQuantity);
+				std::string getIsColdStorage()const;
+				void setIsColdStorage(const std::string& isColdStorage);
+				std::string getCoreInstanceType()const;
+				void setCoreInstanceType(const std::string& coreInstanceType);
+				std::string getCoreDiskSize()const;
+				void setCoreDiskSize(const std::string& coreDiskSize);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
+				std::string getDbType()const;
+				void setDbType(const std::string& dbType);
+				std::string getPayType()const;
+				void setPayType(const std::string& payType);
+
+            private:
+				std::string clusterName_;
+				std::string dbInstanceConnType_;
+				std::string engineVersion_;
+				std::string depMode_;
+				std::string backupId_;
+				std::string dbInstanceType_;
+				std::string vSwitchId_;
+				std::string securityIPList_;
+				std::string autoRenew_;
+				std::string netType_;
+				std::string zoneId_;
+				std::string coreDiskType_;
+				std::string pricingCycle_;
+				std::string coreInstanceQuantity_;
+				std::string duration_;
+				std::string regionId_;
+				std::string engine_;
+				std::string restoreTime_;
+				std::string srcDBInstanceId_;
+				std::string masterInstanceType_;
+				std::string coldStorageSize_;
+				std::string coreDiskQuantity_;
+				std::string isColdStorage_;
+				std::string coreInstanceType_;
+				std::string coreDiskSize_;
+				std::string vpcId_;
+				std::string dbType_;
+				std::string payType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCEREQUEST_H_

hbase/include/alibabacloud/hbase/model/CreateInstanceResult.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_HBASE_MODEL_CREATEINSTANCERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT CreateInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateInstanceResult();
+				explicit CreateInstanceResult(const std::string &payload);
+				~CreateInstanceResult();
+				std::string getClusterId()const;
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string clusterId_;
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEINSTANCERESULT_H_

hbase/include/alibabacloud/hbase/model/DeleteInstanceRequest.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_HBASE_MODEL_DELETEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEINSTANCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DeleteInstanceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteInstanceRequest();
+				~DeleteInstanceRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEINSTANCEREQUEST_H_

hbase/include/alibabacloud/hbase/model/DeleteInstanceResult.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_HBASE_MODEL_DELETEINSTANCERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DeleteInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteInstanceResult();
+				explicit DeleteInstanceResult(const std::string &payload);
+				~DeleteInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEINSTANCERESULT_H_

hbase/include/alibabacloud/hbase/model/DeleteUserHdfsInfoRequest.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_HBASE_MODEL_DELETEUSERHDFSINFOREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEUSERHDFSINFOREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DeleteUserHdfsInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteUserHdfsInfoRequest();
+				~DeleteUserHdfsInfoRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getNameService()const;
+				void setNameService(const std::string& nameService);
+
+            private:
+				std::string clusterId_;
+				std::string nameService_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEUSERHDFSINFOREQUEST_H_

hbase/include/alibabacloud/hbase/model/DeleteUserHdfsInfoResult.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_HBASE_MODEL_DELETEUSERHDFSINFORESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEUSERHDFSINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DeleteUserHdfsInfoResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteUserHdfsInfoResult();
+				explicit DeleteUserHdfsInfoResult(const std::string &payload);
+				~DeleteUserHdfsInfoResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEUSERHDFSINFORESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeEndpointsRequest.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_HBASE_MODEL_DESCRIBEENDPOINTSREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEENDPOINTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeEndpointsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeEndpointsRequest();
+				~DescribeEndpointsRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEENDPOINTSREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeEndpointsResult.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_HBASE_MODEL_DESCRIBEENDPOINTSRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEENDPOINTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeEndpointsResult : public ServiceResult
+			{
+			public:
+				struct ConnAddrInfo
+				{
+					std::string connAddrPort;
+					std::string connAddr;
+					std::string connType;
+					std::string netType;
+				};
+
+
+				DescribeEndpointsResult();
+				explicit DescribeEndpointsResult(const std::string &payload);
+				~DescribeEndpointsResult();
+				std::string getVpcId()const;
+				std::vector<ConnAddrInfo> getConnAddrs()const;
+				std::string getVSwitchId()const;
+				std::string getNetType()const;
+				std::string getEngine()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string vpcId_;
+				std::vector<ConnAddrInfo> connAddrs_;
+				std::string vSwitchId_;
+				std::string netType_;
+				std::string engine_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEENDPOINTSRESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeInstanceRequest.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_HBASE_MODEL_DESCRIBEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeInstanceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeInstanceRequest();
+				~DescribeInstanceRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCEREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeInstanceResult.h

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeInstanceResult : public ServiceResult
+			{
+			public:
+				struct Tag
+				{
+					std::string value;
+					std::string key;
+				};
+
+
+				DescribeInstanceResult();
+				explicit DescribeInstanceResult(const std::string &payload);
+				~DescribeInstanceResult();
+				bool getIsHa()const;
+				std::string getCreatedTime()const;
+				std::string getMasterInstanceType()const;
+				std::string getNetworkType()const;
+				std::string getCoreInstanceType()const;
+				std::string getMasterDiskType()const;
+				std::vector<Tag> getTags()const;
+				std::string getEngine()const;
+				std::string getStatus()const;
+				std::string getMajorVersion()const;
+				std::string getCoreDiskCount()const;
+				int getMasterDiskSize()const;
+				std::string getZoneId()const;
+				std::string getInstanceId()const;
+				int getCoreNodeCount()const;
+				std::string getColdStorageStatus()const;
+				std::string getMinorVersion()const;
+				std::string getPayType()const;
+				std::string getVswitchId()const;
+				std::string getInstanceName()const;
+				int getMasterNodeCount()const;
+				std::string getVpcId()const;
+				std::string getCoreDiskType()const;
+				std::string getRegionId()const;
+				std::string getExpireTime()const;
+				int getCoreDiskSize()const;
+				std::string getBackupStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool isHa_;
+				std::string createdTime_;
+				std::string masterInstanceType_;
+				std::string networkType_;
+				std::string coreInstanceType_;
+				std::string masterDiskType_;
+				std::vector<Tag> tags_;
+				std::string engine_;
+				std::string status_;
+				std::string majorVersion_;
+				std::string coreDiskCount_;
+				int masterDiskSize_;
+				std::string zoneId_;
+				std::string instanceId_;
+				int coreNodeCount_;
+				std::string coldStorageStatus_;
+				std::string minorVersion_;
+				std::string payType_;
+				std::string vswitchId_;
+				std::string instanceName_;
+				int masterNodeCount_;
+				std::string vpcId_;
+				std::string coreDiskType_;
+				std::string regionId_;
+				std::string expireTime_;
+				int coreDiskSize_;
+				std::string backupStatus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCERESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeInstancesRequest.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_HBASE_MODEL_DESCRIBEINSTANCESREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeInstancesRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeInstancesRequest();
+				~DescribeInstancesRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string regionId_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCESREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeInstancesResult.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCESRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeInstancesResult : public ServiceResult
+			{
+			public:
+				struct Instance
+				{
+					std::string status;
+					std::string majorVersion;
+					bool isHa;
+					std::string createdTime;
+					int masterDiskSize;
+					std::string zoneId;
+					std::string instanceId;
+					int coreNodeCount;
+					std::string coldStorageStatus;
+					std::string payType;
+					std::string masterInstanceType;
+					std::string vswitchId;
+					std::string instanceName;
+					int masterNodeCount;
+					std::string vpcId;
+					std::string coreDiskType;
+					std::string networkType;
+					std::string coreInstanceType;
+					std::string masterDiskType;
+					std::string regionId;
+					std::string expireTime;
+					std::string engine;
+					int coreDiskSize;
+					std::string backupStatus;
+				};
+
+
+				DescribeInstancesResult();
+				explicit DescribeInstancesResult(const std::string &payload);
+				~DescribeInstancesResult();
+				std::vector<Instance> getInstances()const;
+				long getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Instance> instances_;
+				long totalCount_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCESRESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.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_HBASE_MODEL_DESCRIBEIPWHITELISTREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEIPWHITELISTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeIpWhitelistRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeIpWhitelistRequest();
+				~DescribeIpWhitelistRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEIPWHITELISTREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeIpWhitelistResult.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_HBASE_MODEL_DESCRIBEIPWHITELISTRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEIPWHITELISTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeIpWhitelistResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeIpWhitelistResult();
+				explicit DescribeIpWhitelistResult(const std::string &payload);
+				~DescribeIpWhitelistResult();
+				std::vector<std::string> getIpList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> ipList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEIPWHITELISTRESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeRegionsRequest.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_HBASE_MODEL_DESCRIBEREGIONSREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEREGIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeRegionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRegionsRequest();
+				~DescribeRegionsRequest();
+
+				std::string getAcceptLanguage()const;
+				void setAcceptLanguage(const std::string& acceptLanguage);
+
+            private:
+				std::string acceptLanguage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEREGIONSREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeRegionsResult.h

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

hbase/include/alibabacloud/hbase/model/DescribeSecurityGroupsRequest.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_HBASE_MODEL_DESCRIBESECURITYGROUPSREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBESECURITYGROUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeSecurityGroupsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeSecurityGroupsRequest();
+				~DescribeSecurityGroupsRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBESECURITYGROUPSREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.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_HBASE_MODEL_DESCRIBESECURITYGROUPSRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBESECURITYGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeSecurityGroupsResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeSecurityGroupsResult();
+				explicit DescribeSecurityGroupsResult(const std::string &payload);
+				~DescribeSecurityGroupsResult();
+				std::vector<std::string> getSecurityGroupIds()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> securityGroupIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBESECURITYGROUPSRESULT_H_

hbase/include/alibabacloud/hbase/model/ModifyInstanceNameRequest.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_HBASE_MODEL_MODIFYINSTANCENAMEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCENAMEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ModifyInstanceNameRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyInstanceNameRequest();
+				~ModifyInstanceNameRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getClusterName()const;
+				void setClusterName(const std::string& clusterName);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+
+            private:
+				std::string clientToken_;
+				std::string clusterName_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				std::string zoneId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCENAMEREQUEST_H_

hbase/include/alibabacloud/hbase/model/ModifyInstanceNameResult.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_HBASE_MODEL_MODIFYINSTANCENAMERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCENAMERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ModifyInstanceNameResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyInstanceNameResult();
+				explicit ModifyInstanceNameResult(const std::string &payload);
+				~ModifyInstanceNameResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCENAMERESULT_H_

hbase/include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.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_HBASE_MODEL_MODIFYIPWHITELISTREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYIPWHITELISTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ModifyIpWhitelistRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyIpWhitelistRequest();
+				~ModifyIpWhitelistRequest();
+
+				std::string getIpList()const;
+				void setIpList(const std::string& ipList);
+				std::string getIpVersion()const;
+				void setIpVersion(const std::string& ipVersion);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getGroupName()const;
+				void setGroupName(const std::string& groupName);
+
+            private:
+				std::string ipList_;
+				std::string ipVersion_;
+				std::string clusterId_;
+				std::string groupName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYIPWHITELISTREQUEST_H_

hbase/include/alibabacloud/hbase/model/ModifyIpWhitelistResult.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_HBASE_MODEL_MODIFYIPWHITELISTRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYIPWHITELISTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ModifyIpWhitelistResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyIpWhitelistResult();
+				explicit ModifyIpWhitelistResult(const std::string &payload);
+				~ModifyIpWhitelistResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYIPWHITELISTRESULT_H_

hbase/include/alibabacloud/hbase/model/ModifySecurityGroupsRequest.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_HBASE_MODEL_MODIFYSECURITYGROUPSREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYSECURITYGROUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ModifySecurityGroupsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifySecurityGroupsRequest();
+				~ModifySecurityGroupsRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getSecurityGroupIds()const;
+				void setSecurityGroupIds(const std::string& securityGroupIds);
+
+            private:
+				std::string clusterId_;
+				std::string securityGroupIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYSECURITYGROUPSREQUEST_H_

hbase/include/alibabacloud/hbase/model/ModifySecurityGroupsResult.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_HBASE_MODEL_MODIFYSECURITYGROUPSRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYSECURITYGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ModifySecurityGroupsResult : public ServiceResult
+			{
+			public:
+
+
+				ModifySecurityGroupsResult();
+				explicit ModifySecurityGroupsResult(const std::string &payload);
+				~ModifySecurityGroupsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYSECURITYGROUPSRESULT_H_

hbase/include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.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_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ModifyUIAccountPasswordRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyUIAccountPasswordRequest();
+				~ModifyUIAccountPasswordRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccountPassword()const;
+				void setAccountPassword(const std::string& accountPassword);
+				std::string getAccountName()const;
+				void setAccountName(const std::string& accountName);
+
+            private:
+				std::string clusterId_;
+				std::string accountPassword_;
+				std::string accountName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDREQUEST_H_

hbase/include/alibabacloud/hbase/model/ModifyUIAccountPasswordResult.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_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ModifyUIAccountPasswordResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyUIAccountPasswordResult();
+				explicit ModifyUIAccountPasswordResult(const std::string &payload);
+				~ModifyUIAccountPasswordResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYUIACCOUNTPASSWORDRESULT_H_

hbase/include/alibabacloud/hbase/model/QueryXpackRelateDBRequest.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_HBASE_MODEL_QUERYXPACKRELATEDBREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_QUERYXPACKRELATEDBREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT QueryXpackRelateDBRequest : public RpcServiceRequest
+			{
+
+			public:
+				QueryXpackRelateDBRequest();
+				~QueryXpackRelateDBRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getRelateDbType()const;
+				void setRelateDbType(const std::string& relateDbType);
+
+            private:
+				std::string clusterId_;
+				std::string relateDbType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_QUERYXPACKRELATEDBREQUEST_H_

hbase/include/alibabacloud/hbase/model/QueryXpackRelateDBResult.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_HBASE_MODEL_QUERYXPACKRELATEDBRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_QUERYXPACKRELATEDBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT QueryXpackRelateDBResult : public ServiceResult
+			{
+			public:
+				struct Cluster
+				{
+					std::string status;
+					std::string dBVersion;
+					bool isRelated;
+					std::string clusterId;
+					std::string clusterName;
+					std::string dBType;
+					std::string lockMode;
+				};
+
+
+				QueryXpackRelateDBResult();
+				explicit QueryXpackRelateDBResult(const std::string &payload);
+				~QueryXpackRelateDBResult();
+				std::vector<Cluster> getClusterList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Cluster> clusterList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_QUERYXPACKRELATEDBRESULT_H_

hbase/include/alibabacloud/hbase/model/RenewInstanceRequest.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_HBASE_MODEL_RENEWINSTANCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_RENEWINSTANCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT RenewInstanceRequest : public RpcServiceRequest
+			{
+
+			public:
+				RenewInstanceRequest();
+				~RenewInstanceRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getDuration()const;
+				void setDuration(int duration);
+				std::string getPricingCycle()const;
+				void setPricingCycle(const std::string& pricingCycle);
+
+            private:
+				std::string clusterId_;
+				int duration_;
+				std::string pricingCycle_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RENEWINSTANCEREQUEST_H_

hbase/include/alibabacloud/hbase/model/RenewInstanceResult.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_HBASE_MODEL_RENEWINSTANCERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_RENEWINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT RenewInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				RenewInstanceResult();
+				explicit RenewInstanceResult(const std::string &payload);
+				~RenewInstanceResult();
+				long getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RENEWINSTANCERESULT_H_

hbase/include/alibabacloud/hbase/model/ResizeDiskSizeRequest.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_HBASE_MODEL_RESIZEDISKSIZEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESIZEDISKSIZEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ResizeDiskSizeRequest : public RpcServiceRequest
+			{
+
+			public:
+				ResizeDiskSizeRequest();
+				~ResizeDiskSizeRequest();
+
+				int getNodeDiskSize()const;
+				void setNodeDiskSize(int nodeDiskSize);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				int nodeDiskSize_;
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEDISKSIZEREQUEST_H_

hbase/include/alibabacloud/hbase/model/ResizeDiskSizeResult.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_HBASE_MODEL_RESIZEDISKSIZERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESIZEDISKSIZERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ResizeDiskSizeResult : public ServiceResult
+			{
+			public:
+
+
+				ResizeDiskSizeResult();
+				explicit ResizeDiskSizeResult(const std::string &payload);
+				~ResizeDiskSizeResult();
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZEDISKSIZERESULT_H_

hbase/include/alibabacloud/hbase/model/ResizeNodeCountRequest.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_HBASE_MODEL_RESIZENODECOUNTREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESIZENODECOUNTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ResizeNodeCountRequest : public RpcServiceRequest
+			{
+
+			public:
+				ResizeNodeCountRequest();
+				~ResizeNodeCountRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getNodeCount()const;
+				void setNodeCount(int nodeCount);
+
+            private:
+				std::string clusterId_;
+				int nodeCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZENODECOUNTREQUEST_H_

hbase/include/alibabacloud/hbase/model/ResizeNodeCountResult.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_HBASE_MODEL_RESIZENODECOUNTRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESIZENODECOUNTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT ResizeNodeCountResult : public ServiceResult
+			{
+			public:
+
+
+				ResizeNodeCountResult();
+				explicit ResizeNodeCountResult(const std::string &payload);
+				~ResizeNodeCountResult();
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESIZENODECOUNTRESULT_H_

hbase/include/alibabacloud/hbase/model/RestartInstanceRequest.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_HBASE_MODEL_RESTARTINSTANCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESTARTINSTANCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT RestartInstanceRequest : public RpcServiceRequest
+			{
+
+			public:
+				RestartInstanceRequest();
+				~RestartInstanceRequest();
+
+				std::string getComponents()const;
+				void setComponents(const std::string& components);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string components_;
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESTARTINSTANCEREQUEST_H_

hbase/include/alibabacloud/hbase/model/RestartInstanceResult.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_HBASE_MODEL_RESTARTINSTANCERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_RESTARTINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT RestartInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				RestartInstanceResult();
+				explicit RestartInstanceResult(const std::string &payload);
+				~RestartInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_RESTARTINSTANCERESULT_H_

hbase/include/alibabacloud/hbase/model/XpackRelateDBRequest.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_HBASE_MODEL_XPACKRELATEDBREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_XPACKRELATEDBREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT XpackRelateDBRequest : public RpcServiceRequest
+			{
+
+			public:
+				XpackRelateDBRequest();
+				~XpackRelateDBRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getRelateDbType()const;
+				void setRelateDbType(const std::string& relateDbType);
+				std::string getDbClusterIds()const;
+				void setDbClusterIds(const std::string& dbClusterIds);
+
+            private:
+				std::string clusterId_;
+				std::string relateDbType_;
+				std::string dbClusterIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_XPACKRELATEDBREQUEST_H_

hbase/include/alibabacloud/hbase/model/XpackRelateDBResult.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_HBASE_MODEL_XPACKRELATEDBRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_XPACKRELATEDBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT XpackRelateDBResult : public ServiceResult
+			{
+			public:
+
+
+				XpackRelateDBResult();
+				explicit XpackRelateDBResult(const std::string &payload);
+				~XpackRelateDBResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_XPACKRELATEDBRESULT_H_

hbase/src/HBaseClient.cc

@@ -0,0 +1,809 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/hbase/HBaseClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "HBase";
+}
+
+HBaseClient::HBaseClient(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, "hbase");
+}
+
+HBaseClient::HBaseClient(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, "hbase");
+}
+
+HBaseClient::HBaseClient(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, "hbase");
+}
+
+HBaseClient::~HBaseClient()
+{}
+
+HBaseClient::AddUserHdfsInfoOutcome HBaseClient::addUserHdfsInfo(const AddUserHdfsInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddUserHdfsInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddUserHdfsInfoOutcome(AddUserHdfsInfoResult(outcome.result()));
+	else
+		return AddUserHdfsInfoOutcome(outcome.error());
+}
+
+void HBaseClient::addUserHdfsInfoAsync(const AddUserHdfsInfoRequest& request, const AddUserHdfsInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addUserHdfsInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::AddUserHdfsInfoOutcomeCallable HBaseClient::addUserHdfsInfoCallable(const AddUserHdfsInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddUserHdfsInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->addUserHdfsInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::ConvertInstanceOutcome HBaseClient::convertInstance(const ConvertInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ConvertInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ConvertInstanceOutcome(ConvertInstanceResult(outcome.result()));
+	else
+		return ConvertInstanceOutcome(outcome.error());
+}
+
+void HBaseClient::convertInstanceAsync(const ConvertInstanceRequest& request, const ConvertInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, convertInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ConvertInstanceOutcomeCallable HBaseClient::convertInstanceCallable(const ConvertInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ConvertInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->convertInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::CreateInstanceOutcome HBaseClient::createInstance(const CreateInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateInstanceOutcome(CreateInstanceResult(outcome.result()));
+	else
+		return CreateInstanceOutcome(outcome.error());
+}
+
+void HBaseClient::createInstanceAsync(const CreateInstanceRequest& request, const CreateInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::CreateInstanceOutcomeCallable HBaseClient::createInstanceCallable(const CreateInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->createInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DeleteInstanceOutcome HBaseClient::deleteInstance(const DeleteInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteInstanceOutcome(DeleteInstanceResult(outcome.result()));
+	else
+		return DeleteInstanceOutcome(outcome.error());
+}
+
+void HBaseClient::deleteInstanceAsync(const DeleteInstanceRequest& request, const DeleteInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DeleteInstanceOutcomeCallable HBaseClient::deleteInstanceCallable(const DeleteInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DeleteUserHdfsInfoOutcome HBaseClient::deleteUserHdfsInfo(const DeleteUserHdfsInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteUserHdfsInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteUserHdfsInfoOutcome(DeleteUserHdfsInfoResult(outcome.result()));
+	else
+		return DeleteUserHdfsInfoOutcome(outcome.error());
+}
+
+void HBaseClient::deleteUserHdfsInfoAsync(const DeleteUserHdfsInfoRequest& request, const DeleteUserHdfsInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteUserHdfsInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DeleteUserHdfsInfoOutcomeCallable HBaseClient::deleteUserHdfsInfoCallable(const DeleteUserHdfsInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteUserHdfsInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteUserHdfsInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeEndpointsOutcome HBaseClient::describeEndpoints(const DescribeEndpointsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeEndpointsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeEndpointsOutcome(DescribeEndpointsResult(outcome.result()));
+	else
+		return DescribeEndpointsOutcome(outcome.error());
+}
+
+void HBaseClient::describeEndpointsAsync(const DescribeEndpointsRequest& request, const DescribeEndpointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeEndpoints(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeEndpointsOutcomeCallable HBaseClient::describeEndpointsCallable(const DescribeEndpointsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeEndpointsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeEndpoints(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeInstanceOutcome HBaseClient::describeInstance(const DescribeInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeInstanceOutcome(DescribeInstanceResult(outcome.result()));
+	else
+		return DescribeInstanceOutcome(outcome.error());
+}
+
+void HBaseClient::describeInstanceAsync(const DescribeInstanceRequest& request, const DescribeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeInstanceOutcomeCallable HBaseClient::describeInstanceCallable(const DescribeInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeInstancesOutcome HBaseClient::describeInstances(const DescribeInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeInstancesOutcome(DescribeInstancesResult(outcome.result()));
+	else
+		return DescribeInstancesOutcome(outcome.error());
+}
+
+void HBaseClient::describeInstancesAsync(const DescribeInstancesRequest& request, const DescribeInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeInstancesOutcomeCallable HBaseClient::describeInstancesCallable(const DescribeInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeIpWhitelistOutcome HBaseClient::describeIpWhitelist(const DescribeIpWhitelistRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeIpWhitelistOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeIpWhitelistOutcome(DescribeIpWhitelistResult(outcome.result()));
+	else
+		return DescribeIpWhitelistOutcome(outcome.error());
+}
+
+void HBaseClient::describeIpWhitelistAsync(const DescribeIpWhitelistRequest& request, const DescribeIpWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeIpWhitelist(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeIpWhitelistOutcomeCallable HBaseClient::describeIpWhitelistCallable(const DescribeIpWhitelistRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeIpWhitelistOutcome()>>(
+			[this, request]()
+			{
+			return this->describeIpWhitelist(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeRegionsOutcome HBaseClient::describeRegions(const DescribeRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
+	else
+		return DescribeRegionsOutcome(outcome.error());
+}
+
+void HBaseClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeRegionsOutcomeCallable HBaseClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeSecurityGroupsOutcome HBaseClient::describeSecurityGroups(const DescribeSecurityGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSecurityGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSecurityGroupsOutcome(DescribeSecurityGroupsResult(outcome.result()));
+	else
+		return DescribeSecurityGroupsOutcome(outcome.error());
+}
+
+void HBaseClient::describeSecurityGroupsAsync(const DescribeSecurityGroupsRequest& request, const DescribeSecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSecurityGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeSecurityGroupsOutcomeCallable HBaseClient::describeSecurityGroupsCallable(const DescribeSecurityGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSecurityGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSecurityGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::ModifyInstanceNameOutcome HBaseClient::modifyInstanceName(const ModifyInstanceNameRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyInstanceNameOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyInstanceNameOutcome(ModifyInstanceNameResult(outcome.result()));
+	else
+		return ModifyInstanceNameOutcome(outcome.error());
+}
+
+void HBaseClient::modifyInstanceNameAsync(const ModifyInstanceNameRequest& request, const ModifyInstanceNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyInstanceName(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ModifyInstanceNameOutcomeCallable HBaseClient::modifyInstanceNameCallable(const ModifyInstanceNameRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyInstanceNameOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyInstanceName(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::ModifyIpWhitelistOutcome HBaseClient::modifyIpWhitelist(const ModifyIpWhitelistRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyIpWhitelistOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyIpWhitelistOutcome(ModifyIpWhitelistResult(outcome.result()));
+	else
+		return ModifyIpWhitelistOutcome(outcome.error());
+}
+
+void HBaseClient::modifyIpWhitelistAsync(const ModifyIpWhitelistRequest& request, const ModifyIpWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyIpWhitelist(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ModifyIpWhitelistOutcomeCallable HBaseClient::modifyIpWhitelistCallable(const ModifyIpWhitelistRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyIpWhitelistOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyIpWhitelist(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::ModifySecurityGroupsOutcome HBaseClient::modifySecurityGroups(const ModifySecurityGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifySecurityGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifySecurityGroupsOutcome(ModifySecurityGroupsResult(outcome.result()));
+	else
+		return ModifySecurityGroupsOutcome(outcome.error());
+}
+
+void HBaseClient::modifySecurityGroupsAsync(const ModifySecurityGroupsRequest& request, const ModifySecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifySecurityGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ModifySecurityGroupsOutcomeCallable HBaseClient::modifySecurityGroupsCallable(const ModifySecurityGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifySecurityGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->modifySecurityGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::ModifyUIAccountPasswordOutcome HBaseClient::modifyUIAccountPassword(const ModifyUIAccountPasswordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyUIAccountPasswordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyUIAccountPasswordOutcome(ModifyUIAccountPasswordResult(outcome.result()));
+	else
+		return ModifyUIAccountPasswordOutcome(outcome.error());
+}
+
+void HBaseClient::modifyUIAccountPasswordAsync(const ModifyUIAccountPasswordRequest& request, const ModifyUIAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyUIAccountPassword(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ModifyUIAccountPasswordOutcomeCallable HBaseClient::modifyUIAccountPasswordCallable(const ModifyUIAccountPasswordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyUIAccountPasswordOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyUIAccountPassword(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::QueryXpackRelateDBOutcome HBaseClient::queryXpackRelateDB(const QueryXpackRelateDBRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryXpackRelateDBOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryXpackRelateDBOutcome(QueryXpackRelateDBResult(outcome.result()));
+	else
+		return QueryXpackRelateDBOutcome(outcome.error());
+}
+
+void HBaseClient::queryXpackRelateDBAsync(const QueryXpackRelateDBRequest& request, const QueryXpackRelateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryXpackRelateDB(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::QueryXpackRelateDBOutcomeCallable HBaseClient::queryXpackRelateDBCallable(const QueryXpackRelateDBRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryXpackRelateDBOutcome()>>(
+			[this, request]()
+			{
+			return this->queryXpackRelateDB(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::RenewInstanceOutcome HBaseClient::renewInstance(const RenewInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RenewInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RenewInstanceOutcome(RenewInstanceResult(outcome.result()));
+	else
+		return RenewInstanceOutcome(outcome.error());
+}
+
+void HBaseClient::renewInstanceAsync(const RenewInstanceRequest& request, const RenewInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, renewInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::RenewInstanceOutcomeCallable HBaseClient::renewInstanceCallable(const RenewInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RenewInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->renewInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::ResizeDiskSizeOutcome HBaseClient::resizeDiskSize(const ResizeDiskSizeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResizeDiskSizeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResizeDiskSizeOutcome(ResizeDiskSizeResult(outcome.result()));
+	else
+		return ResizeDiskSizeOutcome(outcome.error());
+}
+
+void HBaseClient::resizeDiskSizeAsync(const ResizeDiskSizeRequest& request, const ResizeDiskSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resizeDiskSize(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ResizeDiskSizeOutcomeCallable HBaseClient::resizeDiskSizeCallable(const ResizeDiskSizeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResizeDiskSizeOutcome()>>(
+			[this, request]()
+			{
+			return this->resizeDiskSize(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::ResizeNodeCountOutcome HBaseClient::resizeNodeCount(const ResizeNodeCountRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResizeNodeCountOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResizeNodeCountOutcome(ResizeNodeCountResult(outcome.result()));
+	else
+		return ResizeNodeCountOutcome(outcome.error());
+}
+
+void HBaseClient::resizeNodeCountAsync(const ResizeNodeCountRequest& request, const ResizeNodeCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resizeNodeCount(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ResizeNodeCountOutcomeCallable HBaseClient::resizeNodeCountCallable(const ResizeNodeCountRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResizeNodeCountOutcome()>>(
+			[this, request]()
+			{
+			return this->resizeNodeCount(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::RestartInstanceOutcome HBaseClient::restartInstance(const RestartInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RestartInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RestartInstanceOutcome(RestartInstanceResult(outcome.result()));
+	else
+		return RestartInstanceOutcome(outcome.error());
+}
+
+void HBaseClient::restartInstanceAsync(const RestartInstanceRequest& request, const RestartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, restartInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::RestartInstanceOutcomeCallable HBaseClient::restartInstanceCallable(const RestartInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RestartInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->restartInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::XpackRelateDBOutcome HBaseClient::xpackRelateDB(const XpackRelateDBRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return XpackRelateDBOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return XpackRelateDBOutcome(XpackRelateDBResult(outcome.result()));
+	else
+		return XpackRelateDBOutcome(outcome.error());
+}
+
+void HBaseClient::xpackRelateDBAsync(const XpackRelateDBRequest& request, const XpackRelateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, xpackRelateDB(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::XpackRelateDBOutcomeCallable HBaseClient::xpackRelateDBCallable(const XpackRelateDBRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<XpackRelateDBOutcome()>>(
+			[this, request]()
+			{
+			return this->xpackRelateDB(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

hbase/src/model/AddUserHdfsInfoRequest.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/hbase/model/AddUserHdfsInfoRequest.h>
+
+using AlibabaCloud::HBase::Model::AddUserHdfsInfoRequest;
+
+AddUserHdfsInfoRequest::AddUserHdfsInfoRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "AddUserHdfsInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddUserHdfsInfoRequest::~AddUserHdfsInfoRequest()
+{}
+
+std::string AddUserHdfsInfoRequest::getExtInfo()const
+{
+	return extInfo_;
+}
+
+void AddUserHdfsInfoRequest::setExtInfo(const std::string& extInfo)
+{
+	extInfo_ = extInfo;
+	setCoreParameter("ExtInfo", extInfo);
+}
+
+std::string AddUserHdfsInfoRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void AddUserHdfsInfoRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+

hbase/src/model/AddUserHdfsInfoResult.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/hbase/model/AddUserHdfsInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+AddUserHdfsInfoResult::AddUserHdfsInfoResult() :
+	ServiceResult()
+{}
+
+AddUserHdfsInfoResult::AddUserHdfsInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddUserHdfsInfoResult::~AddUserHdfsInfoResult()
+{}
+
+void AddUserHdfsInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

hbase/src/model/ConvertInstanceRequest.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/hbase/model/ConvertInstanceRequest.h>
+
+using AlibabaCloud::HBase::Model::ConvertInstanceRequest;
+
+ConvertInstanceRequest::ConvertInstanceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ConvertInstance")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ConvertInstanceRequest::~ConvertInstanceRequest()
+{}
+
+std::string ConvertInstanceRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ConvertInstanceRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+int ConvertInstanceRequest::getDuration()const
+{
+	return duration_;
+}
+
+void ConvertInstanceRequest::setDuration(int duration)
+{
+	duration_ = duration;
+	setCoreParameter("Duration", std::to_string(duration));
+}
+
+std::string ConvertInstanceRequest::getPricingCycle()const
+{
+	return pricingCycle_;
+}
+
+void ConvertInstanceRequest::setPricingCycle(const std::string& pricingCycle)
+{
+	pricingCycle_ = pricingCycle;
+	setCoreParameter("PricingCycle", pricingCycle);
+}
+

hbase/src/model/ConvertInstanceResult.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/hbase/model/ConvertInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+ConvertInstanceResult::ConvertInstanceResult() :
+	ServiceResult()
+{}
+
+ConvertInstanceResult::ConvertInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ConvertInstanceResult::~ConvertInstanceResult()
+{}
+
+void ConvertInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = std::stol(value["OrderId"].asString());
+
+}
+
+long ConvertInstanceResult::getOrderId()const
+{
+	return orderId_;
+}
+

hbase/src/model/CreateInstanceRequest.cc

@@ -0,0 +1,337 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/hbase/model/CreateInstanceRequest.h>
+
+using AlibabaCloud::HBase::Model::CreateInstanceRequest;
+
+CreateInstanceRequest::CreateInstanceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "CreateInstance")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateInstanceRequest::~CreateInstanceRequest()
+{}
+
+std::string CreateInstanceRequest::getClusterName()const
+{
+	return clusterName_;
+}
+
+void CreateInstanceRequest::setClusterName(const std::string& clusterName)
+{
+	clusterName_ = clusterName;
+	setCoreParameter("ClusterName", clusterName);
+}
+
+std::string CreateInstanceRequest::getDbInstanceConnType()const
+{
+	return dbInstanceConnType_;
+}
+
+void CreateInstanceRequest::setDbInstanceConnType(const std::string& dbInstanceConnType)
+{
+	dbInstanceConnType_ = dbInstanceConnType;
+	setCoreParameter("DbInstanceConnType", dbInstanceConnType);
+}
+
+std::string CreateInstanceRequest::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+void CreateInstanceRequest::setEngineVersion(const std::string& engineVersion)
+{
+	engineVersion_ = engineVersion;
+	setCoreParameter("EngineVersion", engineVersion);
+}
+
+std::string CreateInstanceRequest::getDepMode()const
+{
+	return depMode_;
+}
+
+void CreateInstanceRequest::setDepMode(const std::string& depMode)
+{
+	depMode_ = depMode;
+	setCoreParameter("DepMode", depMode);
+}
+
+std::string CreateInstanceRequest::getBackupId()const
+{
+	return backupId_;
+}
+
+void CreateInstanceRequest::setBackupId(const std::string& backupId)
+{
+	backupId_ = backupId;
+	setCoreParameter("BackupId", backupId);
+}
+
+std::string CreateInstanceRequest::getDbInstanceType()const
+{
+	return dbInstanceType_;
+}
+
+void CreateInstanceRequest::setDbInstanceType(const std::string& dbInstanceType)
+{
+	dbInstanceType_ = dbInstanceType;
+	setCoreParameter("DbInstanceType", dbInstanceType);
+}
+
+std::string CreateInstanceRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateInstanceRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setCoreParameter("VSwitchId", vSwitchId);
+}
+
+std::string CreateInstanceRequest::getSecurityIPList()const
+{
+	return securityIPList_;
+}
+
+void CreateInstanceRequest::setSecurityIPList(const std::string& securityIPList)
+{
+	securityIPList_ = securityIPList;
+	setCoreParameter("SecurityIPList", securityIPList);
+}
+
+std::string CreateInstanceRequest::getAutoRenew()const
+{
+	return autoRenew_;
+}
+
+void CreateInstanceRequest::setAutoRenew(const std::string& autoRenew)
+{
+	autoRenew_ = autoRenew;
+	setCoreParameter("AutoRenew", autoRenew);
+}
+
+std::string CreateInstanceRequest::getNetType()const
+{
+	return netType_;
+}
+
+void CreateInstanceRequest::setNetType(const std::string& netType)
+{
+	netType_ = netType;
+	setCoreParameter("NetType", netType);
+}
+
+std::string CreateInstanceRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void CreateInstanceRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setCoreParameter("ZoneId", zoneId);
+}
+
+std::string CreateInstanceRequest::getCoreDiskType()const
+{
+	return coreDiskType_;
+}
+
+void CreateInstanceRequest::setCoreDiskType(const std::string& coreDiskType)
+{
+	coreDiskType_ = coreDiskType;
+	setCoreParameter("CoreDiskType", coreDiskType);
+}
+
+std::string CreateInstanceRequest::getPricingCycle()const
+{
+	return pricingCycle_;
+}
+
+void CreateInstanceRequest::setPricingCycle(const std::string& pricingCycle)
+{
+	pricingCycle_ = pricingCycle;
+	setCoreParameter("PricingCycle", pricingCycle);
+}
+
+std::string CreateInstanceRequest::getCoreInstanceQuantity()const
+{
+	return coreInstanceQuantity_;
+}
+
+void CreateInstanceRequest::setCoreInstanceQuantity(const std::string& coreInstanceQuantity)
+{
+	coreInstanceQuantity_ = coreInstanceQuantity;
+	setCoreParameter("CoreInstanceQuantity", coreInstanceQuantity);
+}
+
+std::string CreateInstanceRequest::getDuration()const
+{
+	return duration_;
+}
+
+void CreateInstanceRequest::setDuration(const std::string& duration)
+{
+	duration_ = duration;
+	setCoreParameter("Duration", duration);
+}
+
+std::string CreateInstanceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateInstanceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string CreateInstanceRequest::getEngine()const
+{
+	return engine_;
+}
+
+void CreateInstanceRequest::setEngine(const std::string& engine)
+{
+	engine_ = engine;
+	setCoreParameter("Engine", engine);
+}
+
+std::string CreateInstanceRequest::getRestoreTime()const
+{
+	return restoreTime_;
+}
+
+void CreateInstanceRequest::setRestoreTime(const std::string& restoreTime)
+{
+	restoreTime_ = restoreTime;
+	setCoreParameter("RestoreTime", restoreTime);
+}
+
+std::string CreateInstanceRequest::getSrcDBInstanceId()const
+{
+	return srcDBInstanceId_;
+}
+
+void CreateInstanceRequest::setSrcDBInstanceId(const std::string& srcDBInstanceId)
+{
+	srcDBInstanceId_ = srcDBInstanceId;
+	setCoreParameter("SrcDBInstanceId", srcDBInstanceId);
+}
+
+std::string CreateInstanceRequest::getMasterInstanceType()const
+{
+	return masterInstanceType_;
+}
+
+void CreateInstanceRequest::setMasterInstanceType(const std::string& masterInstanceType)
+{
+	masterInstanceType_ = masterInstanceType;
+	setCoreParameter("MasterInstanceType", masterInstanceType);
+}
+
+std::string CreateInstanceRequest::getColdStorageSize()const
+{
+	return coldStorageSize_;
+}
+
+void CreateInstanceRequest::setColdStorageSize(const std::string& coldStorageSize)
+{
+	coldStorageSize_ = coldStorageSize;
+	setCoreParameter("ColdStorageSize", coldStorageSize);
+}
+
+std::string CreateInstanceRequest::getCoreDiskQuantity()const
+{
+	return coreDiskQuantity_;
+}
+
+void CreateInstanceRequest::setCoreDiskQuantity(const std::string& coreDiskQuantity)
+{
+	coreDiskQuantity_ = coreDiskQuantity;
+	setCoreParameter("CoreDiskQuantity", coreDiskQuantity);
+}
+
+std::string CreateInstanceRequest::getIsColdStorage()const
+{
+	return isColdStorage_;
+}
+
+void CreateInstanceRequest::setIsColdStorage(const std::string& isColdStorage)
+{
+	isColdStorage_ = isColdStorage;
+	setCoreParameter("IsColdStorage", isColdStorage);
+}
+
+std::string CreateInstanceRequest::getCoreInstanceType()const
+{
+	return coreInstanceType_;
+}
+
+void CreateInstanceRequest::setCoreInstanceType(const std::string& coreInstanceType)
+{
+	coreInstanceType_ = coreInstanceType;
+	setCoreParameter("CoreInstanceType", coreInstanceType);
+}
+
+std::string CreateInstanceRequest::getCoreDiskSize()const
+{
+	return coreDiskSize_;
+}
+
+void CreateInstanceRequest::setCoreDiskSize(const std::string& coreDiskSize)
+{
+	coreDiskSize_ = coreDiskSize;
+	setCoreParameter("CoreDiskSize", coreDiskSize);
+}
+
+std::string CreateInstanceRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void CreateInstanceRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setCoreParameter("VpcId", vpcId);
+}
+
+std::string CreateInstanceRequest::getDbType()const
+{
+	return dbType_;
+}
+
+void CreateInstanceRequest::setDbType(const std::string& dbType)
+{
+	dbType_ = dbType;
+	setCoreParameter("DbType", dbType);
+}
+
+std::string CreateInstanceRequest::getPayType()const
+{
+	return payType_;
+}
+
+void CreateInstanceRequest::setPayType(const std::string& payType)
+{
+	payType_ = payType;
+	setCoreParameter("PayType", payType);
+}
+

hbase/src/model/CreateInstanceResult.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/hbase/model/CreateInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+CreateInstanceResult::CreateInstanceResult() :
+	ServiceResult()
+{}
+
+CreateInstanceResult::CreateInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateInstanceResult::~CreateInstanceResult()
+{}
+
+void CreateInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ClusterId"].isNull())
+		clusterId_ = value["ClusterId"].asString();
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+
+}
+
+std::string CreateInstanceResult::getClusterId()const
+{
+	return clusterId_;
+}
+
+std::string CreateInstanceResult::getOrderId()const
+{
+	return orderId_;
+}
+

hbase/src/model/DeleteInstanceRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DeleteInstanceRequest.h>
+
+using AlibabaCloud::HBase::Model::DeleteInstanceRequest;
+
+DeleteInstanceRequest::DeleteInstanceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DeleteInstance")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteInstanceRequest::~DeleteInstanceRequest()
+{}
+
+std::string DeleteInstanceRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DeleteInstanceRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+

hbase/src/model/DeleteInstanceResult.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/hbase/model/DeleteInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DeleteInstanceResult::DeleteInstanceResult() :
+	ServiceResult()
+{}
+
+DeleteInstanceResult::DeleteInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteInstanceResult::~DeleteInstanceResult()
+{}
+
+void DeleteInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

hbase/src/model/DeleteUserHdfsInfoRequest.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/hbase/model/DeleteUserHdfsInfoRequest.h>
+
+using AlibabaCloud::HBase::Model::DeleteUserHdfsInfoRequest;
+
+DeleteUserHdfsInfoRequest::DeleteUserHdfsInfoRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DeleteUserHdfsInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteUserHdfsInfoRequest::~DeleteUserHdfsInfoRequest()
+{}
+
+std::string DeleteUserHdfsInfoRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DeleteUserHdfsInfoRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+std::string DeleteUserHdfsInfoRequest::getNameService()const
+{
+	return nameService_;
+}
+
+void DeleteUserHdfsInfoRequest::setNameService(const std::string& nameService)
+{
+	nameService_ = nameService;
+	setCoreParameter("NameService", nameService);
+}
+

hbase/src/model/DeleteUserHdfsInfoResult.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/hbase/model/DeleteUserHdfsInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DeleteUserHdfsInfoResult::DeleteUserHdfsInfoResult() :
+	ServiceResult()
+{}
+
+DeleteUserHdfsInfoResult::DeleteUserHdfsInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteUserHdfsInfoResult::~DeleteUserHdfsInfoResult()
+{}
+
+void DeleteUserHdfsInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

hbase/src/model/DescribeEndpointsRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeEndpointsRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeEndpointsRequest;
+
+DescribeEndpointsRequest::DescribeEndpointsRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeEndpoints")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeEndpointsRequest::~DescribeEndpointsRequest()
+{}
+
+std::string DescribeEndpointsRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DescribeEndpointsRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+

hbase/src/model/DescribeEndpointsResult.cc

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/hbase/model/DescribeEndpointsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeEndpointsResult::DescribeEndpointsResult() :
+	ServiceResult()
+{}
+
+DescribeEndpointsResult::DescribeEndpointsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeEndpointsResult::~DescribeEndpointsResult()
+{}
+
+void DescribeEndpointsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allConnAddrsNode = value["ConnAddrs"]["ConnAddrInfo"];
+	for (auto valueConnAddrsConnAddrInfo : allConnAddrsNode)
+	{
+		ConnAddrInfo connAddrsObject;
+		if(!valueConnAddrsConnAddrInfo["ConnType"].isNull())
+			connAddrsObject.connType = valueConnAddrsConnAddrInfo["ConnType"].asString();
+		if(!valueConnAddrsConnAddrInfo["ConnAddr"].isNull())
+			connAddrsObject.connAddr = valueConnAddrsConnAddrInfo["ConnAddr"].asString();
+		if(!valueConnAddrsConnAddrInfo["ConnAddrPort"].isNull())
+			connAddrsObject.connAddrPort = valueConnAddrsConnAddrInfo["ConnAddrPort"].asString();
+		if(!valueConnAddrsConnAddrInfo["NetType"].isNull())
+			connAddrsObject.netType = valueConnAddrsConnAddrInfo["NetType"].asString();
+		connAddrs_.push_back(connAddrsObject);
+	}
+	if(!value["NetType"].isNull())
+		netType_ = value["NetType"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+	if(!value["VSwitchId"].isNull())
+		vSwitchId_ = value["VSwitchId"].asString();
+	if(!value["Engine"].isNull())
+		engine_ = value["Engine"].asString();
+
+}
+
+std::string DescribeEndpointsResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::vector<DescribeEndpointsResult::ConnAddrInfo> DescribeEndpointsResult::getConnAddrs()const
+{
+	return connAddrs_;
+}
+
+std::string DescribeEndpointsResult::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+std::string DescribeEndpointsResult::getNetType()const
+{
+	return netType_;
+}
+
+std::string DescribeEndpointsResult::getEngine()const
+{
+	return engine_;
+}
+

hbase/src/model/DescribeInstanceRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeInstanceRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeInstanceRequest;
+
+DescribeInstanceRequest::DescribeInstanceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeInstance")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeInstanceRequest::~DescribeInstanceRequest()
+{}
+
+std::string DescribeInstanceRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DescribeInstanceRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+

hbase/src/model/DescribeInstanceResult.cc

@@ -0,0 +1,241 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/hbase/model/DescribeInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeInstanceResult::DescribeInstanceResult() :
+	ServiceResult()
+{}
+
+DescribeInstanceResult::DescribeInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeInstanceResult::~DescribeInstanceResult()
+{}
+
+void DescribeInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["Key"].isNull())
+			tagsObject.key = valueTagsTag["Key"].asString();
+		if(!valueTagsTag["Value"].isNull())
+			tagsObject.value = valueTagsTag["Value"].asString();
+		tags_.push_back(tagsObject);
+	}
+	if(!value["InstanceId"].isNull())
+		instanceId_ = value["InstanceId"].asString();
+	if(!value["InstanceName"].isNull())
+		instanceName_ = value["InstanceName"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["PayType"].isNull())
+		payType_ = value["PayType"].asString();
+	if(!value["CreatedTime"].isNull())
+		createdTime_ = value["CreatedTime"].asString();
+	if(!value["ExpireTime"].isNull())
+		expireTime_ = value["ExpireTime"].asString();
+	if(!value["MajorVersion"].isNull())
+		majorVersion_ = value["MajorVersion"].asString();
+	if(!value["MinorVersion"].isNull())
+		minorVersion_ = value["MinorVersion"].asString();
+	if(!value["Engine"].isNull())
+		engine_ = value["Engine"].asString();
+	if(!value["IsHa"].isNull())
+		isHa_ = value["IsHa"].asString() == "true";
+	if(!value["NetworkType"].isNull())
+		networkType_ = value["NetworkType"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+	if(!value["VswitchId"].isNull())
+		vswitchId_ = value["VswitchId"].asString();
+	if(!value["MasterInstanceType"].isNull())
+		masterInstanceType_ = value["MasterInstanceType"].asString();
+	if(!value["MasterNodeCount"].isNull())
+		masterNodeCount_ = std::stoi(value["MasterNodeCount"].asString());
+	if(!value["MasterDiskType"].isNull())
+		masterDiskType_ = value["MasterDiskType"].asString();
+	if(!value["MasterDiskSize"].isNull())
+		masterDiskSize_ = std::stoi(value["MasterDiskSize"].asString());
+	if(!value["CoreInstanceType"].isNull())
+		coreInstanceType_ = value["CoreInstanceType"].asString();
+	if(!value["CoreNodeCount"].isNull())
+		coreNodeCount_ = std::stoi(value["CoreNodeCount"].asString());
+	if(!value["CoreDiskType"].isNull())
+		coreDiskType_ = value["CoreDiskType"].asString();
+	if(!value["CoreDiskSize"].isNull())
+		coreDiskSize_ = std::stoi(value["CoreDiskSize"].asString());
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["ZoneId"].isNull())
+		zoneId_ = value["ZoneId"].asString();
+	if(!value["ColdStorageStatus"].isNull())
+		coldStorageStatus_ = value["ColdStorageStatus"].asString();
+	if(!value["BackupStatus"].isNull())
+		backupStatus_ = value["BackupStatus"].asString();
+	if(!value["CoreDiskCount"].isNull())
+		coreDiskCount_ = value["CoreDiskCount"].asString();
+
+}
+
+bool DescribeInstanceResult::getIsHa()const
+{
+	return isHa_;
+}
+
+std::string DescribeInstanceResult::getCreatedTime()const
+{
+	return createdTime_;
+}
+
+std::string DescribeInstanceResult::getMasterInstanceType()const
+{
+	return masterInstanceType_;
+}
+
+std::string DescribeInstanceResult::getNetworkType()const
+{
+	return networkType_;
+}
+
+std::string DescribeInstanceResult::getCoreInstanceType()const
+{
+	return coreInstanceType_;
+}
+
+std::string DescribeInstanceResult::getMasterDiskType()const
+{
+	return masterDiskType_;
+}
+
+std::vector<DescribeInstanceResult::Tag> DescribeInstanceResult::getTags()const
+{
+	return tags_;
+}
+
+std::string DescribeInstanceResult::getEngine()const
+{
+	return engine_;
+}
+
+std::string DescribeInstanceResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeInstanceResult::getMajorVersion()const
+{
+	return majorVersion_;
+}
+
+std::string DescribeInstanceResult::getCoreDiskCount()const
+{
+	return coreDiskCount_;
+}
+
+int DescribeInstanceResult::getMasterDiskSize()const
+{
+	return masterDiskSize_;
+}
+
+std::string DescribeInstanceResult::getZoneId()const
+{
+	return zoneId_;
+}
+
+std::string DescribeInstanceResult::getInstanceId()const
+{
+	return instanceId_;
+}
+
+int DescribeInstanceResult::getCoreNodeCount()const
+{
+	return coreNodeCount_;
+}
+
+std::string DescribeInstanceResult::getColdStorageStatus()const
+{
+	return coldStorageStatus_;
+}
+
+std::string DescribeInstanceResult::getMinorVersion()const
+{
+	return minorVersion_;
+}
+
+std::string DescribeInstanceResult::getPayType()const
+{
+	return payType_;
+}
+
+std::string DescribeInstanceResult::getVswitchId()const
+{
+	return vswitchId_;
+}
+
+std::string DescribeInstanceResult::getInstanceName()const
+{
+	return instanceName_;
+}
+
+int DescribeInstanceResult::getMasterNodeCount()const
+{
+	return masterNodeCount_;
+}
+
+std::string DescribeInstanceResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::string DescribeInstanceResult::getCoreDiskType()const
+{
+	return coreDiskType_;
+}
+
+std::string DescribeInstanceResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string DescribeInstanceResult::getExpireTime()const
+{
+	return expireTime_;
+}
+
+int DescribeInstanceResult::getCoreDiskSize()const
+{
+	return coreDiskSize_;
+}
+
+std::string DescribeInstanceResult::getBackupStatus()const
+{
+	return backupStatus_;
+}
+

hbase/src/model/DescribeInstancesRequest.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/hbase/model/DescribeInstancesRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeInstancesRequest;
+
+DescribeInstancesRequest::DescribeInstancesRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeInstances")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeInstancesRequest::~DescribeInstancesRequest()
+{}
+
+int DescribeInstancesRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeInstancesRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeInstancesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeInstancesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+int DescribeInstancesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeInstancesRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setCoreParameter("PageSize", std::to_string(pageSize));
+}
+

hbase/src/model/DescribeInstancesResult.cc

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/hbase/model/DescribeInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeInstancesResult::DescribeInstancesResult() :
+	ServiceResult()
+{}
+
+DescribeInstancesResult::DescribeInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeInstancesResult::~DescribeInstancesResult()
+{}
+
+void DescribeInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstancesNode = value["Instances"]["Instance"];
+	for (auto valueInstancesInstance : allInstancesNode)
+	{
+		Instance instancesObject;
+		if(!valueInstancesInstance["InstanceId"].isNull())
+			instancesObject.instanceId = valueInstancesInstance["InstanceId"].asString();
+		if(!valueInstancesInstance["InstanceName"].isNull())
+			instancesObject.instanceName = valueInstancesInstance["InstanceName"].asString();
+		if(!valueInstancesInstance["Status"].isNull())
+			instancesObject.status = valueInstancesInstance["Status"].asString();
+		if(!valueInstancesInstance["PayType"].isNull())
+			instancesObject.payType = valueInstancesInstance["PayType"].asString();
+		if(!valueInstancesInstance["CreatedTime"].isNull())
+			instancesObject.createdTime = valueInstancesInstance["CreatedTime"].asString();
+		if(!valueInstancesInstance["ExpireTime"].isNull())
+			instancesObject.expireTime = valueInstancesInstance["ExpireTime"].asString();
+		if(!valueInstancesInstance["MajorVersion"].isNull())
+			instancesObject.majorVersion = valueInstancesInstance["MajorVersion"].asString();
+		if(!valueInstancesInstance["Engine"].isNull())
+			instancesObject.engine = valueInstancesInstance["Engine"].asString();
+		if(!valueInstancesInstance["IsHa"].isNull())
+			instancesObject.isHa = valueInstancesInstance["IsHa"].asString() == "true";
+		if(!valueInstancesInstance["NetworkType"].isNull())
+			instancesObject.networkType = valueInstancesInstance["NetworkType"].asString();
+		if(!valueInstancesInstance["VpcId"].isNull())
+			instancesObject.vpcId = valueInstancesInstance["VpcId"].asString();
+		if(!valueInstancesInstance["VswitchId"].isNull())
+			instancesObject.vswitchId = valueInstancesInstance["VswitchId"].asString();
+		if(!valueInstancesInstance["MasterInstanceType"].isNull())
+			instancesObject.masterInstanceType = valueInstancesInstance["MasterInstanceType"].asString();
+		if(!valueInstancesInstance["MasterNodeCount"].isNull())
+			instancesObject.masterNodeCount = std::stoi(valueInstancesInstance["MasterNodeCount"].asString());
+		if(!valueInstancesInstance["MasterDiskType"].isNull())
+			instancesObject.masterDiskType = valueInstancesInstance["MasterDiskType"].asString();
+		if(!valueInstancesInstance["MasterDiskSize"].isNull())
+			instancesObject.masterDiskSize = std::stoi(valueInstancesInstance["MasterDiskSize"].asString());
+		if(!valueInstancesInstance["CoreInstanceType"].isNull())
+			instancesObject.coreInstanceType = valueInstancesInstance["CoreInstanceType"].asString();
+		if(!valueInstancesInstance["CoreNodeCount"].isNull())
+			instancesObject.coreNodeCount = std::stoi(valueInstancesInstance["CoreNodeCount"].asString());
+		if(!valueInstancesInstance["CoreDiskType"].isNull())
+			instancesObject.coreDiskType = valueInstancesInstance["CoreDiskType"].asString();
+		if(!valueInstancesInstance["CoreDiskSize"].isNull())
+			instancesObject.coreDiskSize = std::stoi(valueInstancesInstance["CoreDiskSize"].asString());
+		if(!valueInstancesInstance["RegionId"].isNull())
+			instancesObject.regionId = valueInstancesInstance["RegionId"].asString();
+		if(!valueInstancesInstance["ZoneId"].isNull())
+			instancesObject.zoneId = valueInstancesInstance["ZoneId"].asString();
+		if(!valueInstancesInstance["ColdStorageStatus"].isNull())
+			instancesObject.coldStorageStatus = valueInstancesInstance["ColdStorageStatus"].asString();
+		if(!valueInstancesInstance["BackupStatus"].isNull())
+			instancesObject.backupStatus = valueInstancesInstance["BackupStatus"].asString();
+		instances_.push_back(instancesObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+std::vector<DescribeInstancesResult::Instance> DescribeInstancesResult::getInstances()const
+{
+	return instances_;
+}
+
+long DescribeInstancesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeInstancesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeInstancesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

hbase/src/model/DescribeIpWhitelistRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeIpWhitelistRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeIpWhitelistRequest;
+
+DescribeIpWhitelistRequest::DescribeIpWhitelistRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeIpWhitelist")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeIpWhitelistRequest::~DescribeIpWhitelistRequest()
+{}
+
+std::string DescribeIpWhitelistRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DescribeIpWhitelistRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+

hbase/src/model/DescribeIpWhitelistResult.cc

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/hbase/model/DescribeIpWhitelistResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeIpWhitelistResult::DescribeIpWhitelistResult() :
+	ServiceResult()
+{}
+
+DescribeIpWhitelistResult::DescribeIpWhitelistResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeIpWhitelistResult::~DescribeIpWhitelistResult()
+{}
+
+void DescribeIpWhitelistResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allIpList = value["IpList"]["IP"];
+	for (const auto &item : allIpList)
+		ipList_.push_back(item.asString());
+
+}
+
+std::vector<std::string> DescribeIpWhitelistResult::getIpList()const
+{
+	return ipList_;
+}
+

hbase/src/model/DescribeRegionsRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeRegionsRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeRegionsRequest;
+
+DescribeRegionsRequest::DescribeRegionsRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeRegions")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeRegionsRequest::~DescribeRegionsRequest()
+{}
+
+std::string DescribeRegionsRequest::getAcceptLanguage()const
+{
+	return acceptLanguage_;
+}
+
+void DescribeRegionsRequest::setAcceptLanguage(const std::string& acceptLanguage)
+{
+	acceptLanguage_ = acceptLanguage;
+	setCoreParameter("AcceptLanguage", acceptLanguage);
+}
+

hbase/src/model/DescribeRegionsResult.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/hbase/model/DescribeRegionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeRegionsResult::DescribeRegionsResult() :
+	ServiceResult()
+{}
+
+DescribeRegionsResult::DescribeRegionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRegionsResult::~DescribeRegionsResult()
+{}
+
+void DescribeRegionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRegionsNode = value["Regions"]["Region"];
+	for (auto valueRegionsRegion : allRegionsNode)
+	{
+		Region regionsObject;
+		if(!valueRegionsRegion["RegionId"].isNull())
+			regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
+		if(!valueRegionsRegion["LocalName"].isNull())
+			regionsObject.localName = valueRegionsRegion["LocalName"].asString();
+		if(!valueRegionsRegion["RegionEndpoint"].isNull())
+			regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
+		auto allZonesNode = allRegionsNode["Zones"]["Zone"];
+		for (auto allRegionsNodeZonesZone : allZonesNode)
+		{
+			Region::Zone zonesObject;
+			if(!allRegionsNodeZonesZone["Id"].isNull())
+				zonesObject.id = allRegionsNodeZonesZone["Id"].asString();
+			regionsObject.zones.push_back(zonesObject);
+		}
+		regions_.push_back(regionsObject);
+	}
+
+}
+
+std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
+{
+	return regions_;
+}
+

hbase/src/model/DescribeSecurityGroupsRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeSecurityGroupsRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeSecurityGroupsRequest;
+
+DescribeSecurityGroupsRequest::DescribeSecurityGroupsRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeSecurityGroups")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeSecurityGroupsRequest::~DescribeSecurityGroupsRequest()
+{}
+
+std::string DescribeSecurityGroupsRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DescribeSecurityGroupsRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+

hbase/src/model/DescribeSecurityGroupsResult.cc

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/hbase/model/DescribeSecurityGroupsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeSecurityGroupsResult::DescribeSecurityGroupsResult() :
+	ServiceResult()
+{}
+
+DescribeSecurityGroupsResult::DescribeSecurityGroupsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSecurityGroupsResult::~DescribeSecurityGroupsResult()
+{}
+
+void DescribeSecurityGroupsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSecurityGroupIds = value["SecurityGroupIds"]["SecurityGroupId"];
+	for (const auto &item : allSecurityGroupIds)
+		securityGroupIds_.push_back(item.asString());
+
+}
+
+std::vector<std::string> DescribeSecurityGroupsResult::getSecurityGroupIds()const
+{
+	return securityGroupIds_;
+}
+

hbase/src/model/ModifyInstanceNameRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/hbase/model/ModifyInstanceNameRequest.h>
+
+using AlibabaCloud::HBase::Model::ModifyInstanceNameRequest;
+
+ModifyInstanceNameRequest::ModifyInstanceNameRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ModifyInstanceName")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyInstanceNameRequest::~ModifyInstanceNameRequest()
+{}
+
+std::string ModifyInstanceNameRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void ModifyInstanceNameRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setCoreParameter("ClientToken", clientToken);
+}
+
+std::string ModifyInstanceNameRequest::getClusterName()const
+{
+	return clusterName_;
+}
+
+void ModifyInstanceNameRequest::setClusterName(const std::string& clusterName)
+{
+	clusterName_ = clusterName;
+	setCoreParameter("ClusterName", clusterName);
+}
+
+std::string ModifyInstanceNameRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ModifyInstanceNameRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+std::string ModifyInstanceNameRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyInstanceNameRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyInstanceNameRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifyInstanceNameRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string ModifyInstanceNameRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void ModifyInstanceNameRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setCoreParameter("ZoneId", zoneId);
+}
+

hbase/src/model/ModifyInstanceNameResult.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/hbase/model/ModifyInstanceNameResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+ModifyInstanceNameResult::ModifyInstanceNameResult() :
+	ServiceResult()
+{}
+
+ModifyInstanceNameResult::ModifyInstanceNameResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyInstanceNameResult::~ModifyInstanceNameResult()
+{}
+
+void ModifyInstanceNameResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

hbase/src/model/ModifyIpWhitelistRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/ModifyIpWhitelistRequest.h>
+
+using AlibabaCloud::HBase::Model::ModifyIpWhitelistRequest;
+
+ModifyIpWhitelistRequest::ModifyIpWhitelistRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ModifyIpWhitelist")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyIpWhitelistRequest::~ModifyIpWhitelistRequest()
+{}
+
+std::string ModifyIpWhitelistRequest::getIpList()const
+{
+	return ipList_;
+}
+
+void ModifyIpWhitelistRequest::setIpList(const std::string& ipList)
+{
+	ipList_ = ipList;
+	setCoreParameter("IpList", ipList);
+}
+
+std::string ModifyIpWhitelistRequest::getIpVersion()const
+{
+	return ipVersion_;
+}
+
+void ModifyIpWhitelistRequest::setIpVersion(const std::string& ipVersion)
+{
+	ipVersion_ = ipVersion;
+	setCoreParameter("IpVersion", ipVersion);
+}
+
+std::string ModifyIpWhitelistRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ModifyIpWhitelistRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+std::string ModifyIpWhitelistRequest::getGroupName()const
+{
+	return groupName_;
+}
+
+void ModifyIpWhitelistRequest::setGroupName(const std::string& groupName)
+{
+	groupName_ = groupName;
+	setCoreParameter("GroupName", groupName);
+}
+

hbase/src/model/ModifyIpWhitelistResult.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/hbase/model/ModifyIpWhitelistResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+ModifyIpWhitelistResult::ModifyIpWhitelistResult() :
+	ServiceResult()
+{}
+
+ModifyIpWhitelistResult::ModifyIpWhitelistResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyIpWhitelistResult::~ModifyIpWhitelistResult()
+{}
+
+void ModifyIpWhitelistResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

hbase/src/model/ModifySecurityGroupsRequest.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/hbase/model/ModifySecurityGroupsRequest.h>
+
+using AlibabaCloud::HBase::Model::ModifySecurityGroupsRequest;
+
+ModifySecurityGroupsRequest::ModifySecurityGroupsRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ModifySecurityGroups")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifySecurityGroupsRequest::~ModifySecurityGroupsRequest()
+{}
+
+std::string ModifySecurityGroupsRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ModifySecurityGroupsRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+std::string ModifySecurityGroupsRequest::getSecurityGroupIds()const
+{
+	return securityGroupIds_;
+}
+
+void ModifySecurityGroupsRequest::setSecurityGroupIds(const std::string& securityGroupIds)
+{
+	securityGroupIds_ = securityGroupIds;
+	setCoreParameter("SecurityGroupIds", securityGroupIds);
+}
+

hbase/src/model/ModifySecurityGroupsResult.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/hbase/model/ModifySecurityGroupsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+ModifySecurityGroupsResult::ModifySecurityGroupsResult() :
+	ServiceResult()
+{}
+
+ModifySecurityGroupsResult::ModifySecurityGroupsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifySecurityGroupsResult::~ModifySecurityGroupsResult()
+{}
+
+void ModifySecurityGroupsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

hbase/src/model/ModifyUIAccountPasswordRequest.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/hbase/model/ModifyUIAccountPasswordRequest.h>
+
+using AlibabaCloud::HBase::Model::ModifyUIAccountPasswordRequest;
+
+ModifyUIAccountPasswordRequest::ModifyUIAccountPasswordRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ModifyUIAccountPassword")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyUIAccountPasswordRequest::~ModifyUIAccountPasswordRequest()
+{}
+
+std::string ModifyUIAccountPasswordRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ModifyUIAccountPasswordRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+std::string ModifyUIAccountPasswordRequest::getAccountPassword()const
+{
+	return accountPassword_;
+}
+
+void ModifyUIAccountPasswordRequest::setAccountPassword(const std::string& accountPassword)
+{
+	accountPassword_ = accountPassword;
+	setCoreParameter("AccountPassword", accountPassword);
+}
+
+std::string ModifyUIAccountPasswordRequest::getAccountName()const
+{
+	return accountName_;
+}
+
+void ModifyUIAccountPasswordRequest::setAccountName(const std::string& accountName)
+{
+	accountName_ = accountName;
+	setCoreParameter("AccountName", accountName);
+}
+

hbase/src/model/ModifyUIAccountPasswordResult.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/hbase/model/ModifyUIAccountPasswordResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+ModifyUIAccountPasswordResult::ModifyUIAccountPasswordResult() :
+	ServiceResult()
+{}
+
+ModifyUIAccountPasswordResult::ModifyUIAccountPasswordResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyUIAccountPasswordResult::~ModifyUIAccountPasswordResult()
+{}
+
+void ModifyUIAccountPasswordResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

hbase/src/model/QueryXpackRelateDBRequest.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/hbase/model/QueryXpackRelateDBRequest.h>
+
+using AlibabaCloud::HBase::Model::QueryXpackRelateDBRequest;
+
+QueryXpackRelateDBRequest::QueryXpackRelateDBRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "QueryXpackRelateDB")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+QueryXpackRelateDBRequest::~QueryXpackRelateDBRequest()
+{}
+
+std::string QueryXpackRelateDBRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void QueryXpackRelateDBRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+std::string QueryXpackRelateDBRequest::getRelateDbType()const
+{
+	return relateDbType_;
+}
+
+void QueryXpackRelateDBRequest::setRelateDbType(const std::string& relateDbType)
+{
+	relateDbType_ = relateDbType;
+	setCoreParameter("RelateDbType", relateDbType);
+}
+

hbase/src/model/QueryXpackRelateDBResult.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/hbase/model/QueryXpackRelateDBResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+QueryXpackRelateDBResult::QueryXpackRelateDBResult() :
+	ServiceResult()
+{}
+
+QueryXpackRelateDBResult::QueryXpackRelateDBResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryXpackRelateDBResult::~QueryXpackRelateDBResult()
+{}
+
+void QueryXpackRelateDBResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allClusterListNode = value["ClusterList"]["Cluster"];
+	for (auto valueClusterListCluster : allClusterListNode)
+	{
+		Cluster clusterListObject;
+		if(!valueClusterListCluster["ClusterId"].isNull())
+			clusterListObject.clusterId = valueClusterListCluster["ClusterId"].asString();
+		if(!valueClusterListCluster["ClusterName"].isNull())
+			clusterListObject.clusterName = valueClusterListCluster["ClusterName"].asString();
+		if(!valueClusterListCluster["DBVersion"].isNull())
+			clusterListObject.dBVersion = valueClusterListCluster["DBVersion"].asString();
+		if(!valueClusterListCluster["Status"].isNull())
+			clusterListObject.status = valueClusterListCluster["Status"].asString();
+		if(!valueClusterListCluster["DBType"].isNull())
+			clusterListObject.dBType = valueClusterListCluster["DBType"].asString();
+		if(!valueClusterListCluster["IsRelated"].isNull())
+			clusterListObject.isRelated = valueClusterListCluster["IsRelated"].asString() == "true";
+		if(!valueClusterListCluster["LockMode"].isNull())
+			clusterListObject.lockMode = valueClusterListCluster["LockMode"].asString();
+		clusterList_.push_back(clusterListObject);
+	}
+
+}
+
+std::vector<QueryXpackRelateDBResult::Cluster> QueryXpackRelateDBResult::getClusterList()const
+{
+	return clusterList_;
+}
+

hbase/src/model/RenewInstanceRequest.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/hbase/model/RenewInstanceRequest.h>
+
+using AlibabaCloud::HBase::Model::RenewInstanceRequest;
+
+RenewInstanceRequest::RenewInstanceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "RenewInstance")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RenewInstanceRequest::~RenewInstanceRequest()
+{}
+
+std::string RenewInstanceRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void RenewInstanceRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+int RenewInstanceRequest::getDuration()const
+{
+	return duration_;
+}
+
+void RenewInstanceRequest::setDuration(int duration)
+{
+	duration_ = duration;
+	setCoreParameter("Duration", std::to_string(duration));
+}
+
+std::string RenewInstanceRequest::getPricingCycle()const
+{
+	return pricingCycle_;
+}
+
+void RenewInstanceRequest::setPricingCycle(const std::string& pricingCycle)
+{
+	pricingCycle_ = pricingCycle;
+	setCoreParameter("PricingCycle", pricingCycle);
+}
+

hbase/src/model/RenewInstanceResult.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/hbase/model/RenewInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+RenewInstanceResult::RenewInstanceResult() :
+	ServiceResult()
+{}
+
+RenewInstanceResult::RenewInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RenewInstanceResult::~RenewInstanceResult()
+{}
+
+void RenewInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = std::stol(value["OrderId"].asString());
+
+}
+
+long RenewInstanceResult::getOrderId()const
+{
+	return orderId_;
+}
+

hbase/src/model/ResizeDiskSizeRequest.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/hbase/model/ResizeDiskSizeRequest.h>
+
+using AlibabaCloud::HBase::Model::ResizeDiskSizeRequest;
+
+ResizeDiskSizeRequest::ResizeDiskSizeRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ResizeDiskSize")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ResizeDiskSizeRequest::~ResizeDiskSizeRequest()
+{}
+
+int ResizeDiskSizeRequest::getNodeDiskSize()const
+{
+	return nodeDiskSize_;
+}
+
+void ResizeDiskSizeRequest::setNodeDiskSize(int nodeDiskSize)
+{
+	nodeDiskSize_ = nodeDiskSize;
+	setCoreParameter("NodeDiskSize", std::to_string(nodeDiskSize));
+}
+
+std::string ResizeDiskSizeRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ResizeDiskSizeRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+

hbase/src/model/ResizeDiskSizeResult.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/hbase/model/ResizeDiskSizeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+ResizeDiskSizeResult::ResizeDiskSizeResult() :
+	ServiceResult()
+{}
+
+ResizeDiskSizeResult::ResizeDiskSizeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ResizeDiskSizeResult::~ResizeDiskSizeResult()
+{}
+
+void ResizeDiskSizeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+
+}
+
+std::string ResizeDiskSizeResult::getOrderId()const
+{
+	return orderId_;
+}
+

hbase/src/model/ResizeNodeCountRequest.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/hbase/model/ResizeNodeCountRequest.h>
+
+using AlibabaCloud::HBase::Model::ResizeNodeCountRequest;
+
+ResizeNodeCountRequest::ResizeNodeCountRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ResizeNodeCount")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ResizeNodeCountRequest::~ResizeNodeCountRequest()
+{}
+
+std::string ResizeNodeCountRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ResizeNodeCountRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+int ResizeNodeCountRequest::getNodeCount()const
+{
+	return nodeCount_;
+}
+
+void ResizeNodeCountRequest::setNodeCount(int nodeCount)
+{
+	nodeCount_ = nodeCount;
+	setCoreParameter("NodeCount", std::to_string(nodeCount));
+}
+

hbase/src/model/ResizeNodeCountResult.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/hbase/model/ResizeNodeCountResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+ResizeNodeCountResult::ResizeNodeCountResult() :
+	ServiceResult()
+{}
+
+ResizeNodeCountResult::ResizeNodeCountResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ResizeNodeCountResult::~ResizeNodeCountResult()
+{}
+
+void ResizeNodeCountResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+
+}
+
+std::string ResizeNodeCountResult::getOrderId()const
+{
+	return orderId_;
+}
+

hbase/src/model/RestartInstanceRequest.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/hbase/model/RestartInstanceRequest.h>
+
+using AlibabaCloud::HBase::Model::RestartInstanceRequest;
+
+RestartInstanceRequest::RestartInstanceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "RestartInstance")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RestartInstanceRequest::~RestartInstanceRequest()
+{}
+
+std::string RestartInstanceRequest::getComponents()const
+{
+	return components_;
+}
+
+void RestartInstanceRequest::setComponents(const std::string& components)
+{
+	components_ = components;
+	setCoreParameter("Components", components);
+}
+
+std::string RestartInstanceRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void RestartInstanceRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+

hbase/src/model/RestartInstanceResult.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/hbase/model/RestartInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+RestartInstanceResult::RestartInstanceResult() :
+	ServiceResult()
+{}
+
+RestartInstanceResult::RestartInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RestartInstanceResult::~RestartInstanceResult()
+{}
+
+void RestartInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

hbase/src/model/XpackRelateDBRequest.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/hbase/model/XpackRelateDBRequest.h>
+
+using AlibabaCloud::HBase::Model::XpackRelateDBRequest;
+
+XpackRelateDBRequest::XpackRelateDBRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "XpackRelateDB")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+XpackRelateDBRequest::~XpackRelateDBRequest()
+{}
+
+std::string XpackRelateDBRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void XpackRelateDBRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+std::string XpackRelateDBRequest::getRelateDbType()const
+{
+	return relateDbType_;
+}
+
+void XpackRelateDBRequest::setRelateDbType(const std::string& relateDbType)
+{
+	relateDbType_ = relateDbType;
+	setCoreParameter("RelateDbType", relateDbType);
+}
+
+std::string XpackRelateDBRequest::getDbClusterIds()const
+{
+	return dbClusterIds_;
+}
+
+void XpackRelateDBRequest::setDbClusterIds(const std::string& dbClusterIds)
+{
+	dbClusterIds_ = dbClusterIds;
+	setCoreParameter("DbClusterIds", dbClusterIds);
+}
+

hbase/src/model/XpackRelateDBResult.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/hbase/model/XpackRelateDBResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+XpackRelateDBResult::XpackRelateDBResult() :
+	ServiceResult()
+{}
+
+XpackRelateDBResult::XpackRelateDBResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+XpackRelateDBResult::~XpackRelateDBResult()
+{}
+
+void XpackRelateDBResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+