Generated 2019-01-01 for HBase.

CHANGELOG

@@ -1,3 +1,6 @@
+2019-12-04 Version 1.36.207
+- Generated 2019-01-01 for `HBase`.
+
 2019-12-04 Version 1.36.206
 - Supported ModifyDBInstanceSpec for Direction param.
 

VERSION

@@ -1 +1 @@
-1.36.206
+1.36.207

hbase/CMakeLists.txt

@@ -25,16 +25,24 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/AddUserHdfsInfoResult.h
 	include/alibabacloud/hbase/model/ConvertInstanceRequest.h
 	include/alibabacloud/hbase/model/ConvertInstanceResult.h
+	include/alibabacloud/hbase/model/CreateHbaseHaSlbRequest.h
+	include/alibabacloud/hbase/model/CreateHbaseHaSlbResult.h
 	include/alibabacloud/hbase/model/CreateInstanceRequest.h
 	include/alibabacloud/hbase/model/CreateInstanceResult.h
+	include/alibabacloud/hbase/model/DeleteHbaseHaSlbRequest.h
+	include/alibabacloud/hbase/model/DeleteHbaseHaSlbResult.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/DescribeDBInstanceUsageRequest.h
+	include/alibabacloud/hbase/model/DescribeDBInstanceUsageResult.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/DescribeInstanceTypeRequest.h
+	include/alibabacloud/hbase/model/DescribeInstanceTypeResult.h
 	include/alibabacloud/hbase/model/DescribeInstancesRequest.h
 	include/alibabacloud/hbase/model/DescribeInstancesResult.h
 	include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.h
@@ -43,6 +51,10 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/DescribeRegionsResult.h
 	include/alibabacloud/hbase/model/DescribeSecurityGroupsRequest.h
 	include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.h
+	include/alibabacloud/hbase/model/ListTagResourcesRequest.h
+	include/alibabacloud/hbase/model/ListTagResourcesResult.h
+	include/alibabacloud/hbase/model/ModifyInstanceMaintainTimeRequest.h
+	include/alibabacloud/hbase/model/ModifyInstanceMaintainTimeResult.h
 	include/alibabacloud/hbase/model/ModifyInstanceNameRequest.h
 	include/alibabacloud/hbase/model/ModifyInstanceNameResult.h
 	include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.h
@@ -51,6 +63,8 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/ModifySecurityGroupsResult.h
 	include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.h
 	include/alibabacloud/hbase/model/ModifyUIAccountPasswordResult.h
+	include/alibabacloud/hbase/model/QueryHBaseHaDBRequest.h
+	include/alibabacloud/hbase/model/QueryHBaseHaDBResult.h
 	include/alibabacloud/hbase/model/QueryXpackRelateDBRequest.h
 	include/alibabacloud/hbase/model/QueryXpackRelateDBResult.h
 	include/alibabacloud/hbase/model/RenewInstanceRequest.h
@@ -61,6 +75,12 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/ResizeNodeCountResult.h
 	include/alibabacloud/hbase/model/RestartInstanceRequest.h
 	include/alibabacloud/hbase/model/RestartInstanceResult.h
+	include/alibabacloud/hbase/model/SwitchHbaseHaSlbRequest.h
+	include/alibabacloud/hbase/model/SwitchHbaseHaSlbResult.h
+	include/alibabacloud/hbase/model/TagResourcesRequest.h
+	include/alibabacloud/hbase/model/TagResourcesResult.h
+	include/alibabacloud/hbase/model/UnTagResourcesRequest.h
+	include/alibabacloud/hbase/model/UnTagResourcesResult.h
 	include/alibabacloud/hbase/model/XpackRelateDBRequest.h
 	include/alibabacloud/hbase/model/XpackRelateDBResult.h )
 
@@ -70,16 +90,24 @@ set(hbase_src
 	src/model/AddUserHdfsInfoResult.cc
 	src/model/ConvertInstanceRequest.cc
 	src/model/ConvertInstanceResult.cc
+	src/model/CreateHbaseHaSlbRequest.cc
+	src/model/CreateHbaseHaSlbResult.cc
 	src/model/CreateInstanceRequest.cc
 	src/model/CreateInstanceResult.cc
+	src/model/DeleteHbaseHaSlbRequest.cc
+	src/model/DeleteHbaseHaSlbResult.cc
 	src/model/DeleteInstanceRequest.cc
 	src/model/DeleteInstanceResult.cc
 	src/model/DeleteUserHdfsInfoRequest.cc
 	src/model/DeleteUserHdfsInfoResult.cc
+	src/model/DescribeDBInstanceUsageRequest.cc
+	src/model/DescribeDBInstanceUsageResult.cc
 	src/model/DescribeEndpointsRequest.cc
 	src/model/DescribeEndpointsResult.cc
 	src/model/DescribeInstanceRequest.cc
 	src/model/DescribeInstanceResult.cc
+	src/model/DescribeInstanceTypeRequest.cc
+	src/model/DescribeInstanceTypeResult.cc
 	src/model/DescribeInstancesRequest.cc
 	src/model/DescribeInstancesResult.cc
 	src/model/DescribeIpWhitelistRequest.cc
@@ -88,6 +116,10 @@ set(hbase_src
 	src/model/DescribeRegionsResult.cc
 	src/model/DescribeSecurityGroupsRequest.cc
 	src/model/DescribeSecurityGroupsResult.cc
+	src/model/ListTagResourcesRequest.cc
+	src/model/ListTagResourcesResult.cc
+	src/model/ModifyInstanceMaintainTimeRequest.cc
+	src/model/ModifyInstanceMaintainTimeResult.cc
 	src/model/ModifyInstanceNameRequest.cc
 	src/model/ModifyInstanceNameResult.cc
 	src/model/ModifyIpWhitelistRequest.cc
@@ -96,6 +128,8 @@ set(hbase_src
 	src/model/ModifySecurityGroupsResult.cc
 	src/model/ModifyUIAccountPasswordRequest.cc
 	src/model/ModifyUIAccountPasswordResult.cc
+	src/model/QueryHBaseHaDBRequest.cc
+	src/model/QueryHBaseHaDBResult.cc
 	src/model/QueryXpackRelateDBRequest.cc
 	src/model/QueryXpackRelateDBResult.cc
 	src/model/RenewInstanceRequest.cc
@@ -106,6 +140,12 @@ set(hbase_src
 	src/model/ResizeNodeCountResult.cc
 	src/model/RestartInstanceRequest.cc
 	src/model/RestartInstanceResult.cc
+	src/model/SwitchHbaseHaSlbRequest.cc
+	src/model/SwitchHbaseHaSlbResult.cc
+	src/model/TagResourcesRequest.cc
+	src/model/TagResourcesResult.cc
+	src/model/UnTagResourcesRequest.cc
+	src/model/UnTagResourcesResult.cc
 	src/model/XpackRelateDBRequest.cc
 	src/model/XpackRelateDBResult.cc )
 

hbase/include/alibabacloud/hbase/HBaseClient.h

@@ -26,16 +26,24 @@
 #include "model/AddUserHdfsInfoResult.h"
 #include "model/ConvertInstanceRequest.h"
 #include "model/ConvertInstanceResult.h"
+#include "model/CreateHbaseHaSlbRequest.h"
+#include "model/CreateHbaseHaSlbResult.h"
 #include "model/CreateInstanceRequest.h"
 #include "model/CreateInstanceResult.h"
+#include "model/DeleteHbaseHaSlbRequest.h"
+#include "model/DeleteHbaseHaSlbResult.h"
 #include "model/DeleteInstanceRequest.h"
 #include "model/DeleteInstanceResult.h"
 #include "model/DeleteUserHdfsInfoRequest.h"
 #include "model/DeleteUserHdfsInfoResult.h"
+#include "model/DescribeDBInstanceUsageRequest.h"
+#include "model/DescribeDBInstanceUsageResult.h"
 #include "model/DescribeEndpointsRequest.h"
 #include "model/DescribeEndpointsResult.h"
 #include "model/DescribeInstanceRequest.h"
 #include "model/DescribeInstanceResult.h"
+#include "model/DescribeInstanceTypeRequest.h"
+#include "model/DescribeInstanceTypeResult.h"
 #include "model/DescribeInstancesRequest.h"
 #include "model/DescribeInstancesResult.h"
 #include "model/DescribeIpWhitelistRequest.h"
@@ -44,6 +52,10 @@
 #include "model/DescribeRegionsResult.h"
 #include "model/DescribeSecurityGroupsRequest.h"
 #include "model/DescribeSecurityGroupsResult.h"
+#include "model/ListTagResourcesRequest.h"
+#include "model/ListTagResourcesResult.h"
+#include "model/ModifyInstanceMaintainTimeRequest.h"
+#include "model/ModifyInstanceMaintainTimeResult.h"
 #include "model/ModifyInstanceNameRequest.h"
 #include "model/ModifyInstanceNameResult.h"
 #include "model/ModifyIpWhitelistRequest.h"
@@ -52,6 +64,8 @@
 #include "model/ModifySecurityGroupsResult.h"
 #include "model/ModifyUIAccountPasswordRequest.h"
 #include "model/ModifyUIAccountPasswordResult.h"
+#include "model/QueryHBaseHaDBRequest.h"
+#include "model/QueryHBaseHaDBResult.h"
 #include "model/QueryXpackRelateDBRequest.h"
 #include "model/QueryXpackRelateDBResult.h"
 #include "model/RenewInstanceRequest.h"
@@ -62,6 +76,12 @@
 #include "model/ResizeNodeCountResult.h"
 #include "model/RestartInstanceRequest.h"
 #include "model/RestartInstanceResult.h"
+#include "model/SwitchHbaseHaSlbRequest.h"
+#include "model/SwitchHbaseHaSlbResult.h"
+#include "model/TagResourcesRequest.h"
+#include "model/TagResourcesResult.h"
+#include "model/UnTagResourcesRequest.h"
+#include "model/UnTagResourcesResult.h"
 #include "model/XpackRelateDBRequest.h"
 #include "model/XpackRelateDBResult.h"
 
@@ -79,21 +99,33 @@ namespace AlibabaCloud
 			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::CreateHbaseHaSlbResult> CreateHbaseHaSlbOutcome;
+			typedef std::future<CreateHbaseHaSlbOutcome> CreateHbaseHaSlbOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::CreateHbaseHaSlbRequest&, const CreateHbaseHaSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHbaseHaSlbAsyncHandler;
 			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::DeleteHbaseHaSlbResult> DeleteHbaseHaSlbOutcome;
+			typedef std::future<DeleteHbaseHaSlbOutcome> DeleteHbaseHaSlbOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DeleteHbaseHaSlbRequest&, const DeleteHbaseHaSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHbaseHaSlbAsyncHandler;
 			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::DescribeDBInstanceUsageResult> DescribeDBInstanceUsageOutcome;
+			typedef std::future<DescribeDBInstanceUsageOutcome> DescribeDBInstanceUsageOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeDBInstanceUsageRequest&, const DescribeDBInstanceUsageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceUsageAsyncHandler;
 			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::DescribeInstanceTypeResult> DescribeInstanceTypeOutcome;
+			typedef std::future<DescribeInstanceTypeOutcome> DescribeInstanceTypeOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeInstanceTypeRequest&, const DescribeInstanceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceTypeAsyncHandler;
 			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;
@@ -106,6 +138,12 @@ namespace AlibabaCloud
 			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::ListTagResourcesResult> ListTagResourcesOutcome;
+			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::ModifyInstanceMaintainTimeResult> ModifyInstanceMaintainTimeOutcome;
+			typedef std::future<ModifyInstanceMaintainTimeOutcome> ModifyInstanceMaintainTimeOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ModifyInstanceMaintainTimeRequest&, const ModifyInstanceMaintainTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceMaintainTimeAsyncHandler;
 			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;
@@ -118,6 +156,9 @@ namespace AlibabaCloud
 			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::QueryHBaseHaDBResult> QueryHBaseHaDBOutcome;
+			typedef std::future<QueryHBaseHaDBOutcome> QueryHBaseHaDBOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::QueryHBaseHaDBRequest&, const QueryHBaseHaDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryHBaseHaDBAsyncHandler;
 			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;
@@ -133,6 +174,15 @@ namespace AlibabaCloud
 			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::SwitchHbaseHaSlbResult> SwitchHbaseHaSlbOutcome;
+			typedef std::future<SwitchHbaseHaSlbOutcome> SwitchHbaseHaSlbOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::SwitchHbaseHaSlbRequest&, const SwitchHbaseHaSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwitchHbaseHaSlbAsyncHandler;
+			typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
+			typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::UnTagResourcesResult> UnTagResourcesOutcome;
+			typedef std::future<UnTagResourcesOutcome> UnTagResourcesOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::UnTagResourcesRequest&, const UnTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnTagResourcesAsyncHandler;
 			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;
@@ -147,21 +197,33 @@ namespace AlibabaCloud
 			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;
+			CreateHbaseHaSlbOutcome createHbaseHaSlb(const Model::CreateHbaseHaSlbRequest &request)const;
+			void createHbaseHaSlbAsync(const Model::CreateHbaseHaSlbRequest& request, const CreateHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateHbaseHaSlbOutcomeCallable createHbaseHaSlbCallable(const Model::CreateHbaseHaSlbRequest& 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;
+			DeleteHbaseHaSlbOutcome deleteHbaseHaSlb(const Model::DeleteHbaseHaSlbRequest &request)const;
+			void deleteHbaseHaSlbAsync(const Model::DeleteHbaseHaSlbRequest& request, const DeleteHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteHbaseHaSlbOutcomeCallable deleteHbaseHaSlbCallable(const Model::DeleteHbaseHaSlbRequest& 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;
+			DescribeDBInstanceUsageOutcome describeDBInstanceUsage(const Model::DescribeDBInstanceUsageRequest &request)const;
+			void describeDBInstanceUsageAsync(const Model::DescribeDBInstanceUsageRequest& request, const DescribeDBInstanceUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBInstanceUsageOutcomeCallable describeDBInstanceUsageCallable(const Model::DescribeDBInstanceUsageRequest& 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;
+			DescribeInstanceTypeOutcome describeInstanceType(const Model::DescribeInstanceTypeRequest &request)const;
+			void describeInstanceTypeAsync(const Model::DescribeInstanceTypeRequest& request, const DescribeInstanceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeInstanceTypeOutcomeCallable describeInstanceTypeCallable(const Model::DescribeInstanceTypeRequest& 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;
@@ -174,6 +236,12 @@ namespace AlibabaCloud
 			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;
+			ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
+			void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
+			ModifyInstanceMaintainTimeOutcome modifyInstanceMaintainTime(const Model::ModifyInstanceMaintainTimeRequest &request)const;
+			void modifyInstanceMaintainTimeAsync(const Model::ModifyInstanceMaintainTimeRequest& request, const ModifyInstanceMaintainTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyInstanceMaintainTimeOutcomeCallable modifyInstanceMaintainTimeCallable(const Model::ModifyInstanceMaintainTimeRequest& 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;
@@ -186,6 +254,9 @@ namespace AlibabaCloud
 			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;
+			QueryHBaseHaDBOutcome queryHBaseHaDB(const Model::QueryHBaseHaDBRequest &request)const;
+			void queryHBaseHaDBAsync(const Model::QueryHBaseHaDBRequest& request, const QueryHBaseHaDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryHBaseHaDBOutcomeCallable queryHBaseHaDBCallable(const Model::QueryHBaseHaDBRequest& 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;
@@ -201,6 +272,15 @@ namespace AlibabaCloud
 			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;
+			SwitchHbaseHaSlbOutcome switchHbaseHaSlb(const Model::SwitchHbaseHaSlbRequest &request)const;
+			void switchHbaseHaSlbAsync(const Model::SwitchHbaseHaSlbRequest& request, const SwitchHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SwitchHbaseHaSlbOutcomeCallable switchHbaseHaSlbCallable(const Model::SwitchHbaseHaSlbRequest& request) const;
+			TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
+			void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
+			UnTagResourcesOutcome unTagResources(const Model::UnTagResourcesRequest &request)const;
+			void unTagResourcesAsync(const Model::UnTagResourcesRequest& request, const UnTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UnTagResourcesOutcomeCallable unTagResourcesCallable(const Model::UnTagResourcesRequest& 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;

hbase/include/alibabacloud/hbase/model/CreateHbaseHaSlbRequest.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_CREATEHBASEHASLBREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBREQUEST_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 CreateHbaseHaSlbRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateHbaseHaSlbRequest();
+				~CreateHbaseHaSlbRequest();
+
+				std::string getHaTypes()const;
+				void setHaTypes(const std::string& haTypes);
+				std::string getHbaseType()const;
+				void setHbaseType(const std::string& hbaseType);
+				std::string getBdsId()const;
+				void setBdsId(const std::string& bdsId);
+				std::string getHaId()const;
+				void setHaId(const std::string& haId);
+
+            private:
+				std::string haTypes_;
+				std::string hbaseType_;
+				std::string bdsId_;
+				std::string haId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBREQUEST_H_

hbase/include/alibabacloud/hbase/model/CreateHbaseHaSlbResult.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_CREATEHBASEHASLBRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBRESULT_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 CreateHbaseHaSlbResult : public ServiceResult
+			{
+			public:
+
+
+				CreateHbaseHaSlbResult();
+				explicit CreateHbaseHaSlbResult(const std::string &payload);
+				~CreateHbaseHaSlbResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBRESULT_H_

hbase/include/alibabacloud/hbase/model/DeleteHbaseHaSlbRequest.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_DELETEHBASEHASLBREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHASLBREQUEST_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 DeleteHbaseHaSlbRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteHbaseHaSlbRequest();
+				~DeleteHbaseHaSlbRequest();
+
+				std::string getHaId()const;
+				void setHaId(const std::string& haId);
+				std::string getHaTypes()const;
+				void setHaTypes(const std::string& haTypes);
+				std::string getBdsId()const;
+				void setBdsId(const std::string& bdsId);
+
+            private:
+				std::string haId_;
+				std::string haTypes_;
+				std::string bdsId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHASLBREQUEST_H_

hbase/include/alibabacloud/hbase/model/DeleteHbaseHaSlbResult.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_DELETEHBASEHASLBRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHASLBRESULT_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 DeleteHbaseHaSlbResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteHbaseHaSlbResult();
+				explicit DeleteHbaseHaSlbResult(const std::string &payload);
+				~DeleteHbaseHaSlbResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHASLBRESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeDBInstanceUsageRequest.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_DESCRIBEDBINSTANCEUSAGEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGEREQUEST_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 DescribeDBInstanceUsageRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDBInstanceUsageRequest();
+				~DescribeDBInstanceUsageRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGEREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeDBInstanceUsageResult.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_DESCRIBEDBINSTANCEUSAGERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGERESULT_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 DescribeDBInstanceUsageResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDBInstanceUsageResult();
+				explicit DescribeDBInstanceUsageResult(const std::string &payload);
+				~DescribeDBInstanceUsageResult();
+				std::string getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGERESULT_H_

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

@@ -45,11 +45,13 @@ namespace AlibabaCloud
 				bool getIsHa()const;
 				std::string getCreatedTime()const;
 				std::string getMasterInstanceType()const;
+				std::string getMaintainEndTime()const;
 				std::string getNetworkType()const;
 				std::string getCoreInstanceType()const;
 				std::string getMasterDiskType()const;
 				std::vector<Tag> getTags()const;
 				std::string getEngine()const;
+				std::string getMaintainStartTime()const;
 				std::string getStatus()const;
 				std::string getMajorVersion()const;
 				std::string getCoreDiskCount()const;
@@ -76,11 +78,13 @@ namespace AlibabaCloud
 				bool isHa_;
 				std::string createdTime_;
 				std::string masterInstanceType_;
+				std::string maintainEndTime_;
 				std::string networkType_;
 				std::string coreInstanceType_;
 				std::string masterDiskType_;
 				std::vector<Tag> tags_;
 				std::string engine_;
+				std::string maintainStartTime_;
 				std::string status_;
 				std::string majorVersion_;
 				std::string coreDiskCount_;

hbase/include/alibabacloud/hbase/model/DescribeInstanceTypeRequest.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_DESCRIBEINSTANCETYPEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCETYPEREQUEST_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 DescribeInstanceTypeRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeInstanceTypeRequest();
+				~DescribeInstanceTypeRequest();
+
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
+
+            private:
+				std::string instanceType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCETYPEREQUEST_H_

hbase/include/alibabacloud/hbase/model/DescribeInstanceTypeResult.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_DESCRIBEINSTANCETYPERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCETYPERESULT_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 DescribeInstanceTypeResult : public ServiceResult
+			{
+			public:
+				struct InstanceTypeSpec
+				{
+					long cpuSize;
+					long memSize;
+					std::string instanceType;
+				};
+
+
+				DescribeInstanceTypeResult();
+				explicit DescribeInstanceTypeResult(const std::string &payload);
+				~DescribeInstanceTypeResult();
+				std::vector<InstanceTypeSpec> getInstanceTypeSpecList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<InstanceTypeSpec> instanceTypeSpecList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCETYPERESULT_H_

hbase/include/alibabacloud/hbase/model/ListTagResourcesRequest.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_LISTTAGRESOURCESREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_LISTTAGRESOURCESREQUEST_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 ListTagResourcesRequest : public RpcServiceRequest
+			{
+				struct Tag
+				{
+					std::string value;
+					std::string key;
+				};
+
+			public:
+				ListTagResourcesRequest();
+				~ListTagResourcesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::vector<Tag> getTag()const;
+				void setTag(const std::vector<Tag>& tag);
+				std::vector<std::string> getResourceId()const;
+				void setResourceId(const std::vector<std::string>& resourceId);
+
+            private:
+				std::string regionId_;
+				std::string nextToken_;
+				std::vector<Tag> tag_;
+				std::vector<std::string> resourceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_LISTTAGRESOURCESREQUEST_H_

hbase/include/alibabacloud/hbase/model/ListTagResourcesResult.h

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

hbase/include/alibabacloud/hbase/model/ModifyInstanceMaintainTimeRequest.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_MODIFYINSTANCEMAINTAINTIMEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMEREQUEST_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 ModifyInstanceMaintainTimeRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyInstanceMaintainTimeRequest();
+				~ModifyInstanceMaintainTimeRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getMaintainEndTime()const;
+				void setMaintainEndTime(const std::string& maintainEndTime);
+				std::string getMaintainStartTime()const;
+				void setMaintainStartTime(const std::string& maintainStartTime);
+
+            private:
+				std::string clusterId_;
+				std::string maintainEndTime_;
+				std::string maintainStartTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMEREQUEST_H_

hbase/include/alibabacloud/hbase/model/ModifyInstanceMaintainTimeResult.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_MODIFYINSTANCEMAINTAINTIMERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMERESULT_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 ModifyInstanceMaintainTimeResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyInstanceMaintainTimeResult();
+				explicit ModifyInstanceMaintainTimeResult(const std::string &payload);
+				~ModifyInstanceMaintainTimeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMERESULT_H_

hbase/include/alibabacloud/hbase/model/QueryHBaseHaDBRequest.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_QUERYHBASEHADBREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_QUERYHBASEHADBREQUEST_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 QueryHBaseHaDBRequest : public RpcServiceRequest
+			{
+
+			public:
+				QueryHBaseHaDBRequest();
+				~QueryHBaseHaDBRequest();
+
+				std::string getBdsId()const;
+				void setBdsId(const std::string& bdsId);
+
+            private:
+				std::string bdsId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_QUERYHBASEHADBREQUEST_H_

hbase/include/alibabacloud/hbase/model/QueryHBaseHaDBResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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_QUERYHBASEHADBRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_QUERYHBASEHADBRESULT_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 QueryHBaseHaDBResult : public ServiceResult
+			{
+			public:
+				struct Cluster
+				{
+					struct HaSlbConn
+					{
+						std::string hbaseType;
+						std::string slbType;
+						std::string slbConnAddr;
+					};
+					std::string activeName;
+					std::string bdsName;
+					std::string haName;
+					std::string standbyName;
+					std::vector<Cluster::HaSlbConn> haSlbConnList;
+				};
+
+
+				QueryHBaseHaDBResult();
+				explicit QueryHBaseHaDBResult(const std::string &payload);
+				~QueryHBaseHaDBResult();
+				long getTotalCount()const;
+				std::vector<Cluster> getClusterList()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::vector<Cluster> clusterList_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_QUERYHBASEHADBRESULT_H_

hbase/include/alibabacloud/hbase/model/SwitchHbaseHaSlbRequest.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_SWITCHHBASEHASLBREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBREQUEST_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 SwitchHbaseHaSlbRequest : public RpcServiceRequest
+			{
+
+			public:
+				SwitchHbaseHaSlbRequest();
+				~SwitchHbaseHaSlbRequest();
+
+				std::string getHaTypes()const;
+				void setHaTypes(const std::string& haTypes);
+				std::string getHbaseType()const;
+				void setHbaseType(const std::string& hbaseType);
+				std::string getBdsId()const;
+				void setBdsId(const std::string& bdsId);
+				std::string getHaId()const;
+				void setHaId(const std::string& haId);
+
+            private:
+				std::string haTypes_;
+				std::string hbaseType_;
+				std::string bdsId_;
+				std::string haId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBREQUEST_H_

hbase/include/alibabacloud/hbase/model/SwitchHbaseHaSlbResult.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_SWITCHHBASEHASLBRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBRESULT_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 SwitchHbaseHaSlbResult : public ServiceResult
+			{
+			public:
+
+
+				SwitchHbaseHaSlbResult();
+				explicit SwitchHbaseHaSlbResult(const std::string &payload);
+				~SwitchHbaseHaSlbResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBRESULT_H_

hbase/include/alibabacloud/hbase/model/TagResourcesRequest.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESREQUEST_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 TagResourcesRequest : public RpcServiceRequest
+			{
+				struct Tag
+				{
+					std::string value;
+					std::string key;
+				};
+
+			public:
+				TagResourcesRequest();
+				~TagResourcesRequest();
+
+				std::vector<std::string> getResourceId()const;
+				void setResourceId(const std::vector<std::string>& resourceId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::vector<Tag> getTag()const;
+				void setTag(const std::vector<Tag>& tag);
+
+            private:
+				std::vector<std::string> resourceId_;
+				std::string regionId_;
+				std::vector<Tag> tag_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESREQUEST_H_

hbase/include/alibabacloud/hbase/model/TagResourcesResult.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_TAGRESOURCESRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESRESULT_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 TagResourcesResult : public ServiceResult
+			{
+			public:
+
+
+				TagResourcesResult();
+				explicit TagResourcesResult(const std::string &payload);
+				~TagResourcesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESRESULT_H_

hbase/include/alibabacloud/hbase/model/UnTagResourcesRequest.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_UNTAGRESOURCESREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESREQUEST_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 UnTagResourcesRequest : public RpcServiceRequest
+			{
+
+			public:
+				UnTagResourcesRequest();
+				~UnTagResourcesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getAll()const;
+				void setAll(bool all);
+				std::vector<std::string> getResourceId()const;
+				void setResourceId(const std::vector<std::string>& resourceId);
+				std::vector<std::string> getTagKey()const;
+				void setTagKey(const std::vector<std::string>& tagKey);
+
+            private:
+				std::string regionId_;
+				bool all_;
+				std::vector<std::string> resourceId_;
+				std::vector<std::string> tagKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESREQUEST_H_

hbase/include/alibabacloud/hbase/model/UnTagResourcesResult.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_UNTAGRESOURCESRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESRESULT_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 UnTagResourcesResult : public ServiceResult
+			{
+			public:
+
+
+				UnTagResourcesResult();
+				explicit UnTagResourcesResult(const std::string &payload);
+				~UnTagResourcesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESRESULT_H_

hbase/src/HBaseClient.cc

@@ -123,6 +123,42 @@ HBaseClient::ConvertInstanceOutcomeCallable HBaseClient::convertInstanceCallable
 	return task->get_future();
 }
 
+HBaseClient::CreateHbaseHaSlbOutcome HBaseClient::createHbaseHaSlb(const CreateHbaseHaSlbRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateHbaseHaSlbOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateHbaseHaSlbOutcome(CreateHbaseHaSlbResult(outcome.result()));
+	else
+		return CreateHbaseHaSlbOutcome(outcome.error());
+}
+
+void HBaseClient::createHbaseHaSlbAsync(const CreateHbaseHaSlbRequest& request, const CreateHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createHbaseHaSlb(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::CreateHbaseHaSlbOutcomeCallable HBaseClient::createHbaseHaSlbCallable(const CreateHbaseHaSlbRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateHbaseHaSlbOutcome()>>(
+			[this, request]()
+			{
+			return this->createHbaseHaSlb(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::CreateInstanceOutcome HBaseClient::createInstance(const CreateInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +195,42 @@ HBaseClient::CreateInstanceOutcomeCallable HBaseClient::createInstanceCallable(c
 	return task->get_future();
 }
 
+HBaseClient::DeleteHbaseHaSlbOutcome HBaseClient::deleteHbaseHaSlb(const DeleteHbaseHaSlbRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteHbaseHaSlbOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteHbaseHaSlbOutcome(DeleteHbaseHaSlbResult(outcome.result()));
+	else
+		return DeleteHbaseHaSlbOutcome(outcome.error());
+}
+
+void HBaseClient::deleteHbaseHaSlbAsync(const DeleteHbaseHaSlbRequest& request, const DeleteHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteHbaseHaSlb(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DeleteHbaseHaSlbOutcomeCallable HBaseClient::deleteHbaseHaSlbCallable(const DeleteHbaseHaSlbRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteHbaseHaSlbOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteHbaseHaSlb(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DeleteInstanceOutcome HBaseClient::deleteInstance(const DeleteInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +303,42 @@ HBaseClient::DeleteUserHdfsInfoOutcomeCallable HBaseClient::deleteUserHdfsInfoCa
 	return task->get_future();
 }
 
+HBaseClient::DescribeDBInstanceUsageOutcome HBaseClient::describeDBInstanceUsage(const DescribeDBInstanceUsageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBInstanceUsageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBInstanceUsageOutcome(DescribeDBInstanceUsageResult(outcome.result()));
+	else
+		return DescribeDBInstanceUsageOutcome(outcome.error());
+}
+
+void HBaseClient::describeDBInstanceUsageAsync(const DescribeDBInstanceUsageRequest& request, const DescribeDBInstanceUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBInstanceUsage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeDBInstanceUsageOutcomeCallable HBaseClient::describeDBInstanceUsageCallable(const DescribeDBInstanceUsageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBInstanceUsageOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBInstanceUsage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DescribeEndpointsOutcome HBaseClient::describeEndpoints(const DescribeEndpointsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +411,42 @@ HBaseClient::DescribeInstanceOutcomeCallable HBaseClient::describeInstanceCallab
 	return task->get_future();
 }
 
+HBaseClient::DescribeInstanceTypeOutcome HBaseClient::describeInstanceType(const DescribeInstanceTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeInstanceTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeInstanceTypeOutcome(DescribeInstanceTypeResult(outcome.result()));
+	else
+		return DescribeInstanceTypeOutcome(outcome.error());
+}
+
+void HBaseClient::describeInstanceTypeAsync(const DescribeInstanceTypeRequest& request, const DescribeInstanceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeInstanceType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeInstanceTypeOutcomeCallable HBaseClient::describeInstanceTypeCallable(const DescribeInstanceTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeInstanceTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeInstanceType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DescribeInstancesOutcome HBaseClient::describeInstances(const DescribeInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,6 +591,78 @@ HBaseClient::DescribeSecurityGroupsOutcomeCallable HBaseClient::describeSecurity
 	return task->get_future();
 }
 
+HBaseClient::ListTagResourcesOutcome HBaseClient::listTagResources(const ListTagResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTagResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTagResourcesOutcome(ListTagResourcesResult(outcome.result()));
+	else
+		return ListTagResourcesOutcome(outcome.error());
+}
+
+void HBaseClient::listTagResourcesAsync(const ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTagResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ListTagResourcesOutcomeCallable HBaseClient::listTagResourcesCallable(const ListTagResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTagResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->listTagResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::ModifyInstanceMaintainTimeOutcome HBaseClient::modifyInstanceMaintainTime(const ModifyInstanceMaintainTimeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyInstanceMaintainTimeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyInstanceMaintainTimeOutcome(ModifyInstanceMaintainTimeResult(outcome.result()));
+	else
+		return ModifyInstanceMaintainTimeOutcome(outcome.error());
+}
+
+void HBaseClient::modifyInstanceMaintainTimeAsync(const ModifyInstanceMaintainTimeRequest& request, const ModifyInstanceMaintainTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyInstanceMaintainTime(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ModifyInstanceMaintainTimeOutcomeCallable HBaseClient::modifyInstanceMaintainTimeCallable(const ModifyInstanceMaintainTimeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyInstanceMaintainTimeOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyInstanceMaintainTime(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::ModifyInstanceNameOutcome HBaseClient::modifyInstanceName(const ModifyInstanceNameRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -591,6 +807,42 @@ HBaseClient::ModifyUIAccountPasswordOutcomeCallable HBaseClient::modifyUIAccount
 	return task->get_future();
 }
 
+HBaseClient::QueryHBaseHaDBOutcome HBaseClient::queryHBaseHaDB(const QueryHBaseHaDBRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryHBaseHaDBOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryHBaseHaDBOutcome(QueryHBaseHaDBResult(outcome.result()));
+	else
+		return QueryHBaseHaDBOutcome(outcome.error());
+}
+
+void HBaseClient::queryHBaseHaDBAsync(const QueryHBaseHaDBRequest& request, const QueryHBaseHaDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryHBaseHaDB(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::QueryHBaseHaDBOutcomeCallable HBaseClient::queryHBaseHaDBCallable(const QueryHBaseHaDBRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryHBaseHaDBOutcome()>>(
+			[this, request]()
+			{
+			return this->queryHBaseHaDB(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::QueryXpackRelateDBOutcome HBaseClient::queryXpackRelateDB(const QueryXpackRelateDBRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -771,6 +1023,114 @@ HBaseClient::RestartInstanceOutcomeCallable HBaseClient::restartInstanceCallable
 	return task->get_future();
 }
 
+HBaseClient::SwitchHbaseHaSlbOutcome HBaseClient::switchHbaseHaSlb(const SwitchHbaseHaSlbRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SwitchHbaseHaSlbOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SwitchHbaseHaSlbOutcome(SwitchHbaseHaSlbResult(outcome.result()));
+	else
+		return SwitchHbaseHaSlbOutcome(outcome.error());
+}
+
+void HBaseClient::switchHbaseHaSlbAsync(const SwitchHbaseHaSlbRequest& request, const SwitchHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, switchHbaseHaSlb(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::SwitchHbaseHaSlbOutcomeCallable HBaseClient::switchHbaseHaSlbCallable(const SwitchHbaseHaSlbRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SwitchHbaseHaSlbOutcome()>>(
+			[this, request]()
+			{
+			return this->switchHbaseHaSlb(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::TagResourcesOutcome HBaseClient::tagResources(const TagResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TagResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TagResourcesOutcome(TagResourcesResult(outcome.result()));
+	else
+		return TagResourcesOutcome(outcome.error());
+}
+
+void HBaseClient::tagResourcesAsync(const TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, tagResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::TagResourcesOutcomeCallable HBaseClient::tagResourcesCallable(const TagResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TagResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->tagResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::UnTagResourcesOutcome HBaseClient::unTagResources(const UnTagResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UnTagResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UnTagResourcesOutcome(UnTagResourcesResult(outcome.result()));
+	else
+		return UnTagResourcesOutcome(outcome.error());
+}
+
+void HBaseClient::unTagResourcesAsync(const UnTagResourcesRequest& request, const UnTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, unTagResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::UnTagResourcesOutcomeCallable HBaseClient::unTagResourcesCallable(const UnTagResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UnTagResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->unTagResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::XpackRelateDBOutcome HBaseClient::xpackRelateDB(const XpackRelateDBRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

hbase/src/model/CreateHbaseHaSlbRequest.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/CreateHbaseHaSlbRequest.h>
+
+using AlibabaCloud::HBase::Model::CreateHbaseHaSlbRequest;
+
+CreateHbaseHaSlbRequest::CreateHbaseHaSlbRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "CreateHbaseHaSlb")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateHbaseHaSlbRequest::~CreateHbaseHaSlbRequest()
+{}
+
+std::string CreateHbaseHaSlbRequest::getHaTypes()const
+{
+	return haTypes_;
+}
+
+void CreateHbaseHaSlbRequest::setHaTypes(const std::string& haTypes)
+{
+	haTypes_ = haTypes;
+	setCoreParameter("HaTypes", haTypes);
+}
+
+std::string CreateHbaseHaSlbRequest::getHbaseType()const
+{
+	return hbaseType_;
+}
+
+void CreateHbaseHaSlbRequest::setHbaseType(const std::string& hbaseType)
+{
+	hbaseType_ = hbaseType;
+	setCoreParameter("HbaseType", hbaseType);
+}
+
+std::string CreateHbaseHaSlbRequest::getBdsId()const
+{
+	return bdsId_;
+}
+
+void CreateHbaseHaSlbRequest::setBdsId(const std::string& bdsId)
+{
+	bdsId_ = bdsId;
+	setCoreParameter("BdsId", bdsId);
+}
+
+std::string CreateHbaseHaSlbRequest::getHaId()const
+{
+	return haId_;
+}
+
+void CreateHbaseHaSlbRequest::setHaId(const std::string& haId)
+{
+	haId_ = haId;
+	setCoreParameter("HaId", haId);
+}
+

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

hbase/src/model/DeleteHbaseHaSlbRequest.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/DeleteHbaseHaSlbRequest.h>
+
+using AlibabaCloud::HBase::Model::DeleteHbaseHaSlbRequest;
+
+DeleteHbaseHaSlbRequest::DeleteHbaseHaSlbRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DeleteHbaseHaSlb")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteHbaseHaSlbRequest::~DeleteHbaseHaSlbRequest()
+{}
+
+std::string DeleteHbaseHaSlbRequest::getHaId()const
+{
+	return haId_;
+}
+
+void DeleteHbaseHaSlbRequest::setHaId(const std::string& haId)
+{
+	haId_ = haId;
+	setCoreParameter("HaId", haId);
+}
+
+std::string DeleteHbaseHaSlbRequest::getHaTypes()const
+{
+	return haTypes_;
+}
+
+void DeleteHbaseHaSlbRequest::setHaTypes(const std::string& haTypes)
+{
+	haTypes_ = haTypes;
+	setCoreParameter("HaTypes", haTypes);
+}
+
+std::string DeleteHbaseHaSlbRequest::getBdsId()const
+{
+	return bdsId_;
+}
+
+void DeleteHbaseHaSlbRequest::setBdsId(const std::string& bdsId)
+{
+	bdsId_ = bdsId;
+	setCoreParameter("BdsId", bdsId);
+}
+

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

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

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

hbase/src/model/DescribeInstanceResult.cc

@@ -101,6 +101,10 @@ void DescribeInstanceResult::parse(const std::string &payload)
 		backupStatus_ = value["BackupStatus"].asString();
 	if(!value["CoreDiskCount"].isNull())
 		coreDiskCount_ = value["CoreDiskCount"].asString();
+	if(!value["MaintainStartTime"].isNull())
+		maintainStartTime_ = value["MaintainStartTime"].asString();
+	if(!value["MaintainEndTime"].isNull())
+		maintainEndTime_ = value["MaintainEndTime"].asString();
 
 }
 
@@ -119,6 +123,11 @@ std::string DescribeInstanceResult::getMasterInstanceType()const
 	return masterInstanceType_;
 }
 
+std::string DescribeInstanceResult::getMaintainEndTime()const
+{
+	return maintainEndTime_;
+}
+
 std::string DescribeInstanceResult::getNetworkType()const
 {
 	return networkType_;
@@ -144,6 +153,11 @@ std::string DescribeInstanceResult::getEngine()const
 	return engine_;
 }
 
+std::string DescribeInstanceResult::getMaintainStartTime()const
+{
+	return maintainStartTime_;
+}
+
 std::string DescribeInstanceResult::getStatus()const
 {
 	return status_;

hbase/src/model/DescribeInstanceTypeRequest.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/DescribeInstanceTypeRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeInstanceTypeRequest;
+
+DescribeInstanceTypeRequest::DescribeInstanceTypeRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeInstanceType")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeInstanceTypeRequest::~DescribeInstanceTypeRequest()
+{}
+
+std::string DescribeInstanceTypeRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void DescribeInstanceTypeRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setCoreParameter("InstanceType", instanceType);
+}
+

hbase/src/model/DescribeInstanceTypeResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/hbase/model/DescribeInstanceTypeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeInstanceTypeResult::DescribeInstanceTypeResult() :
+	ServiceResult()
+{}
+
+DescribeInstanceTypeResult::DescribeInstanceTypeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeInstanceTypeResult::~DescribeInstanceTypeResult()
+{}
+
+void DescribeInstanceTypeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstanceTypeSpecListNode = value["InstanceTypeSpecList"]["InstanceTypeSpec"];
+	for (auto valueInstanceTypeSpecListInstanceTypeSpec : allInstanceTypeSpecListNode)
+	{
+		InstanceTypeSpec instanceTypeSpecListObject;
+		if(!valueInstanceTypeSpecListInstanceTypeSpec["InstanceType"].isNull())
+			instanceTypeSpecListObject.instanceType = valueInstanceTypeSpecListInstanceTypeSpec["InstanceType"].asString();
+		if(!valueInstanceTypeSpecListInstanceTypeSpec["CpuSize"].isNull())
+			instanceTypeSpecListObject.cpuSize = std::stol(valueInstanceTypeSpecListInstanceTypeSpec["CpuSize"].asString());
+		if(!valueInstanceTypeSpecListInstanceTypeSpec["MemSize"].isNull())
+			instanceTypeSpecListObject.memSize = std::stol(valueInstanceTypeSpecListInstanceTypeSpec["MemSize"].asString());
+		instanceTypeSpecList_.push_back(instanceTypeSpecListObject);
+	}
+
+}
+
+std::vector<DescribeInstanceTypeResult::InstanceTypeSpec> DescribeInstanceTypeResult::getInstanceTypeSpecList()const
+{
+	return instanceTypeSpecList_;
+}
+

hbase/src/model/ListTagResourcesRequest.cc

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ListTagResourcesRequest.h>
+
+using AlibabaCloud::HBase::Model::ListTagResourcesRequest;
+
+ListTagResourcesRequest::ListTagResourcesRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ListTagResources")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListTagResourcesRequest::~ListTagResourcesRequest()
+{}
+
+std::string ListTagResourcesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListTagResourcesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string ListTagResourcesRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void ListTagResourcesRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setCoreParameter("NextToken", nextToken);
+}
+
+std::vector<ListTagResourcesRequest::Tag> ListTagResourcesRequest::getTag()const
+{
+	return tag_;
+}
+
+void ListTagResourcesRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1);
+		setCoreParameter(tagObjStr + ".Value", tagObj.value);
+		setCoreParameter(tagObjStr + ".Key", tagObj.key);
+	}
+}
+
+std::vector<std::string> ListTagResourcesRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void ListTagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
+{
+	resourceId_ = resourceId;
+	for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
+		setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
+	}
+}
+

hbase/src/model/ListTagResourcesResult.cc

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/ListTagResourcesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+ListTagResourcesResult::ListTagResourcesResult() :
+	ServiceResult()
+{}
+
+ListTagResourcesResult::ListTagResourcesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListTagResourcesResult::~ListTagResourcesResult()
+{}
+
+void ListTagResourcesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagResourcesNode = value["TagResources"]["TagResource"];
+	for (auto valueTagResourcesTagResource : allTagResourcesNode)
+	{
+		TagResource tagResourcesObject;
+		if(!valueTagResourcesTagResource["TagKey"].isNull())
+			tagResourcesObject.tagKey = valueTagResourcesTagResource["TagKey"].asString();
+		if(!valueTagResourcesTagResource["TagValue"].isNull())
+			tagResourcesObject.tagValue = valueTagResourcesTagResource["TagValue"].asString();
+		if(!valueTagResourcesTagResource["ResourceType"].isNull())
+			tagResourcesObject.resourceType = valueTagResourcesTagResource["ResourceType"].asString();
+		if(!valueTagResourcesTagResource["ResourceId"].isNull())
+			tagResourcesObject.resourceId = valueTagResourcesTagResource["ResourceId"].asString();
+		tagResources_.push_back(tagResourcesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::string ListTagResourcesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<ListTagResourcesResult::TagResource> ListTagResourcesResult::getTagResources()const
+{
+	return tagResources_;
+}
+

hbase/src/model/ModifyInstanceMaintainTimeRequest.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/ModifyInstanceMaintainTimeRequest.h>
+
+using AlibabaCloud::HBase::Model::ModifyInstanceMaintainTimeRequest;
+
+ModifyInstanceMaintainTimeRequest::ModifyInstanceMaintainTimeRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "ModifyInstanceMaintainTime")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyInstanceMaintainTimeRequest::~ModifyInstanceMaintainTimeRequest()
+{}
+
+std::string ModifyInstanceMaintainTimeRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void ModifyInstanceMaintainTimeRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setCoreParameter("ClusterId", clusterId);
+}
+
+std::string ModifyInstanceMaintainTimeRequest::getMaintainEndTime()const
+{
+	return maintainEndTime_;
+}
+
+void ModifyInstanceMaintainTimeRequest::setMaintainEndTime(const std::string& maintainEndTime)
+{
+	maintainEndTime_ = maintainEndTime;
+	setCoreParameter("MaintainEndTime", maintainEndTime);
+}
+
+std::string ModifyInstanceMaintainTimeRequest::getMaintainStartTime()const
+{
+	return maintainStartTime_;
+}
+
+void ModifyInstanceMaintainTimeRequest::setMaintainStartTime(const std::string& maintainStartTime)
+{
+	maintainStartTime_ = maintainStartTime;
+	setCoreParameter("MaintainStartTime", maintainStartTime);
+}
+

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

hbase/src/model/QueryHBaseHaDBRequest.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/QueryHBaseHaDBRequest.h>
+
+using AlibabaCloud::HBase::Model::QueryHBaseHaDBRequest;
+
+QueryHBaseHaDBRequest::QueryHBaseHaDBRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "QueryHBaseHaDB")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+QueryHBaseHaDBRequest::~QueryHBaseHaDBRequest()
+{}
+
+std::string QueryHBaseHaDBRequest::getBdsId()const
+{
+	return bdsId_;
+}
+
+void QueryHBaseHaDBRequest::setBdsId(const std::string& bdsId)
+{
+	bdsId_ = bdsId;
+	setCoreParameter("BdsId", bdsId);
+}
+

hbase/src/model/QueryHBaseHaDBResult.cc

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/QueryHBaseHaDBResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+QueryHBaseHaDBResult::QueryHBaseHaDBResult() :
+	ServiceResult()
+{}
+
+QueryHBaseHaDBResult::QueryHBaseHaDBResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryHBaseHaDBResult::~QueryHBaseHaDBResult()
+{}
+
+void QueryHBaseHaDBResult::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["HaName"].isNull())
+			clusterListObject.haName = valueClusterListCluster["HaName"].asString();
+		if(!valueClusterListCluster["BdsName"].isNull())
+			clusterListObject.bdsName = valueClusterListCluster["BdsName"].asString();
+		if(!valueClusterListCluster["ActiveName"].isNull())
+			clusterListObject.activeName = valueClusterListCluster["ActiveName"].asString();
+		if(!valueClusterListCluster["StandbyName"].isNull())
+			clusterListObject.standbyName = valueClusterListCluster["StandbyName"].asString();
+		auto allHaSlbConnListNode = allClusterListNode["HaSlbConnList"]["HaSlbConn"];
+		for (auto allClusterListNodeHaSlbConnListHaSlbConn : allHaSlbConnListNode)
+		{
+			Cluster::HaSlbConn haSlbConnListObject;
+			if(!allClusterListNodeHaSlbConnListHaSlbConn["SlbType"].isNull())
+				haSlbConnListObject.slbType = allClusterListNodeHaSlbConnListHaSlbConn["SlbType"].asString();
+			if(!allClusterListNodeHaSlbConnListHaSlbConn["SlbConnAddr"].isNull())
+				haSlbConnListObject.slbConnAddr = allClusterListNodeHaSlbConnListHaSlbConn["SlbConnAddr"].asString();
+			if(!allClusterListNodeHaSlbConnListHaSlbConn["HbaseType"].isNull())
+				haSlbConnListObject.hbaseType = allClusterListNodeHaSlbConnListHaSlbConn["HbaseType"].asString();
+			clusterListObject.haSlbConnList.push_back(haSlbConnListObject);
+		}
+		clusterList_.push_back(clusterListObject);
+	}
+	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());
+
+}
+
+long QueryHBaseHaDBResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<QueryHBaseHaDBResult::Cluster> QueryHBaseHaDBResult::getClusterList()const
+{
+	return clusterList_;
+}
+
+int QueryHBaseHaDBResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int QueryHBaseHaDBResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

hbase/src/model/SwitchHbaseHaSlbRequest.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/SwitchHbaseHaSlbRequest.h>
+
+using AlibabaCloud::HBase::Model::SwitchHbaseHaSlbRequest;
+
+SwitchHbaseHaSlbRequest::SwitchHbaseHaSlbRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "SwitchHbaseHaSlb")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SwitchHbaseHaSlbRequest::~SwitchHbaseHaSlbRequest()
+{}
+
+std::string SwitchHbaseHaSlbRequest::getHaTypes()const
+{
+	return haTypes_;
+}
+
+void SwitchHbaseHaSlbRequest::setHaTypes(const std::string& haTypes)
+{
+	haTypes_ = haTypes;
+	setCoreParameter("HaTypes", haTypes);
+}
+
+std::string SwitchHbaseHaSlbRequest::getHbaseType()const
+{
+	return hbaseType_;
+}
+
+void SwitchHbaseHaSlbRequest::setHbaseType(const std::string& hbaseType)
+{
+	hbaseType_ = hbaseType;
+	setCoreParameter("HbaseType", hbaseType);
+}
+
+std::string SwitchHbaseHaSlbRequest::getBdsId()const
+{
+	return bdsId_;
+}
+
+void SwitchHbaseHaSlbRequest::setBdsId(const std::string& bdsId)
+{
+	bdsId_ = bdsId;
+	setCoreParameter("BdsId", bdsId);
+}
+
+std::string SwitchHbaseHaSlbRequest::getHaId()const
+{
+	return haId_;
+}
+
+void SwitchHbaseHaSlbRequest::setHaId(const std::string& haId)
+{
+	haId_ = haId;
+	setCoreParameter("HaId", haId);
+}
+

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

hbase/src/model/TagResourcesRequest.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/TagResourcesRequest.h>
+
+using AlibabaCloud::HBase::Model::TagResourcesRequest;
+
+TagResourcesRequest::TagResourcesRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "TagResources")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+TagResourcesRequest::~TagResourcesRequest()
+{}
+
+std::vector<std::string> TagResourcesRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void TagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
+{
+	resourceId_ = resourceId;
+	for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
+		setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
+	}
+}
+
+std::string TagResourcesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void TagResourcesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::vector<TagResourcesRequest::Tag> TagResourcesRequest::getTag()const
+{
+	return tag_;
+}
+
+void TagResourcesRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1);
+		setCoreParameter(tagObjStr + ".Value", tagObj.value);
+		setCoreParameter(tagObjStr + ".Key", tagObj.key);
+	}
+}
+

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

hbase/src/model/UnTagResourcesRequest.cc

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/UnTagResourcesRequest.h>
+
+using AlibabaCloud::HBase::Model::UnTagResourcesRequest;
+
+UnTagResourcesRequest::UnTagResourcesRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "UnTagResources")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UnTagResourcesRequest::~UnTagResourcesRequest()
+{}
+
+std::string UnTagResourcesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void UnTagResourcesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+bool UnTagResourcesRequest::getAll()const
+{
+	return all_;
+}
+
+void UnTagResourcesRequest::setAll(bool all)
+{
+	all_ = all;
+	setCoreParameter("All", all ? "true" : "false");
+}
+
+std::vector<std::string> UnTagResourcesRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void UnTagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
+{
+	resourceId_ = resourceId;
+	for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
+		setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
+	}
+}
+
+std::vector<std::string> UnTagResourcesRequest::getTagKey()const
+{
+	return tagKey_;
+}
+
+void UnTagResourcesRequest::setTagKey(const std::vector<std::string>& tagKey)
+{
+	tagKey_ = tagKey;
+	for(int dep1 = 0; dep1!= tagKey.size(); dep1++) {
+		setCoreParameter("TagKey."+ std::to_string(dep1), tagKey.at(dep1));
+	}
+}
+

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