regenerate code

hbase/CMakeLists.txt

@@ -25,18 +25,30 @@ 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/CreateBackupPlanRequest.h
+	include/alibabacloud/hbase/model/CreateBackupPlanResult.h
 	include/alibabacloud/hbase/model/CreateClusterRequest.h
 	include/alibabacloud/hbase/model/CreateClusterResult.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/CreateRestorePlanRequest.h
+	include/alibabacloud/hbase/model/CreateRestorePlanResult.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/DescribeBackupPlanConfigRequest.h
+	include/alibabacloud/hbase/model/DescribeBackupPlanConfigResult.h
+	include/alibabacloud/hbase/model/DescribeBackupStatusRequest.h
+	include/alibabacloud/hbase/model/DescribeBackupStatusResult.h
+	include/alibabacloud/hbase/model/DescribeBackupSummaryRequest.h
+	include/alibabacloud/hbase/model/DescribeBackupSummaryResult.h
+	include/alibabacloud/hbase/model/DescribeBackupTablesRequest.h
+	include/alibabacloud/hbase/model/DescribeBackupTablesResult.h
 	include/alibabacloud/hbase/model/DescribeDBInstanceUsageRequest.h
 	include/alibabacloud/hbase/model/DescribeDBInstanceUsageResult.h
 	include/alibabacloud/hbase/model/DescribeEndpointsRequest.h
@@ -49,14 +61,24 @@ set(hbase_public_header_model
 	include/alibabacloud/hbase/model/DescribeInstancesResult.h
 	include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.h
 	include/alibabacloud/hbase/model/DescribeIpWhitelistResult.h
+	include/alibabacloud/hbase/model/DescribeRecoverableTimeRangeRequest.h
+	include/alibabacloud/hbase/model/DescribeRecoverableTimeRangeResult.h
 	include/alibabacloud/hbase/model/DescribeRegionsRequest.h
 	include/alibabacloud/hbase/model/DescribeRegionsResult.h
+	include/alibabacloud/hbase/model/DescribeRestoreSummaryRequest.h
+	include/alibabacloud/hbase/model/DescribeRestoreSummaryResult.h
+	include/alibabacloud/hbase/model/DescribeRestoreTablesRequest.h
+	include/alibabacloud/hbase/model/DescribeRestoreTablesResult.h
 	include/alibabacloud/hbase/model/DescribeSecurityGroupsRequest.h
 	include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.h
+	include/alibabacloud/hbase/model/EnableHBaseueBackupRequest.h
+	include/alibabacloud/hbase/model/EnableHBaseueBackupResult.h
 	include/alibabacloud/hbase/model/ListTagResourcesRequest.h
 	include/alibabacloud/hbase/model/ListTagResourcesResult.h
 	include/alibabacloud/hbase/model/ListTagsRequest.h
 	include/alibabacloud/hbase/model/ListTagsResult.h
+	include/alibabacloud/hbase/model/ModifyBackupPlanConfigRequest.h
+	include/alibabacloud/hbase/model/ModifyBackupPlanConfigResult.h
 	include/alibabacloud/hbase/model/ModifyClusterDeletionProtectionRequest.h
 	include/alibabacloud/hbase/model/ModifyClusterDeletionProtectionResult.h
 	include/alibabacloud/hbase/model/ModifyInstanceMaintainTimeRequest.h
@@ -96,18 +118,30 @@ set(hbase_src
 	src/model/AddUserHdfsInfoResult.cc
 	src/model/ConvertInstanceRequest.cc
 	src/model/ConvertInstanceResult.cc
+	src/model/CreateBackupPlanRequest.cc
+	src/model/CreateBackupPlanResult.cc
 	src/model/CreateClusterRequest.cc
 	src/model/CreateClusterResult.cc
 	src/model/CreateHbaseHaSlbRequest.cc
 	src/model/CreateHbaseHaSlbResult.cc
 	src/model/CreateInstanceRequest.cc
 	src/model/CreateInstanceResult.cc
+	src/model/CreateRestorePlanRequest.cc
+	src/model/CreateRestorePlanResult.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/DescribeBackupPlanConfigRequest.cc
+	src/model/DescribeBackupPlanConfigResult.cc
+	src/model/DescribeBackupStatusRequest.cc
+	src/model/DescribeBackupStatusResult.cc
+	src/model/DescribeBackupSummaryRequest.cc
+	src/model/DescribeBackupSummaryResult.cc
+	src/model/DescribeBackupTablesRequest.cc
+	src/model/DescribeBackupTablesResult.cc
 	src/model/DescribeDBInstanceUsageRequest.cc
 	src/model/DescribeDBInstanceUsageResult.cc
 	src/model/DescribeEndpointsRequest.cc
@@ -120,14 +154,24 @@ set(hbase_src
 	src/model/DescribeInstancesResult.cc
 	src/model/DescribeIpWhitelistRequest.cc
 	src/model/DescribeIpWhitelistResult.cc
+	src/model/DescribeRecoverableTimeRangeRequest.cc
+	src/model/DescribeRecoverableTimeRangeResult.cc
 	src/model/DescribeRegionsRequest.cc
 	src/model/DescribeRegionsResult.cc
+	src/model/DescribeRestoreSummaryRequest.cc
+	src/model/DescribeRestoreSummaryResult.cc
+	src/model/DescribeRestoreTablesRequest.cc
+	src/model/DescribeRestoreTablesResult.cc
 	src/model/DescribeSecurityGroupsRequest.cc
 	src/model/DescribeSecurityGroupsResult.cc
+	src/model/EnableHBaseueBackupRequest.cc
+	src/model/EnableHBaseueBackupResult.cc
 	src/model/ListTagResourcesRequest.cc
 	src/model/ListTagResourcesResult.cc
 	src/model/ListTagsRequest.cc
 	src/model/ListTagsResult.cc
+	src/model/ModifyBackupPlanConfigRequest.cc
+	src/model/ModifyBackupPlanConfigResult.cc
 	src/model/ModifyClusterDeletionProtectionRequest.cc
 	src/model/ModifyClusterDeletionProtectionResult.cc
 	src/model/ModifyInstanceMaintainTimeRequest.cc

hbase/include/alibabacloud/hbase/HBaseClient.h

@@ -26,18 +26,30 @@
 #include "model/AddUserHdfsInfoResult.h"
 #include "model/ConvertInstanceRequest.h"
 #include "model/ConvertInstanceResult.h"
+#include "model/CreateBackupPlanRequest.h"
+#include "model/CreateBackupPlanResult.h"
 #include "model/CreateClusterRequest.h"
 #include "model/CreateClusterResult.h"
 #include "model/CreateHbaseHaSlbRequest.h"
 #include "model/CreateHbaseHaSlbResult.h"
 #include "model/CreateInstanceRequest.h"
 #include "model/CreateInstanceResult.h"
+#include "model/CreateRestorePlanRequest.h"
+#include "model/CreateRestorePlanResult.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/DescribeBackupPlanConfigRequest.h"
+#include "model/DescribeBackupPlanConfigResult.h"
+#include "model/DescribeBackupStatusRequest.h"
+#include "model/DescribeBackupStatusResult.h"
+#include "model/DescribeBackupSummaryRequest.h"
+#include "model/DescribeBackupSummaryResult.h"
+#include "model/DescribeBackupTablesRequest.h"
+#include "model/DescribeBackupTablesResult.h"
 #include "model/DescribeDBInstanceUsageRequest.h"
 #include "model/DescribeDBInstanceUsageResult.h"
 #include "model/DescribeEndpointsRequest.h"
@@ -50,14 +62,24 @@
 #include "model/DescribeInstancesResult.h"
 #include "model/DescribeIpWhitelistRequest.h"
 #include "model/DescribeIpWhitelistResult.h"
+#include "model/DescribeRecoverableTimeRangeRequest.h"
+#include "model/DescribeRecoverableTimeRangeResult.h"
 #include "model/DescribeRegionsRequest.h"
 #include "model/DescribeRegionsResult.h"
+#include "model/DescribeRestoreSummaryRequest.h"
+#include "model/DescribeRestoreSummaryResult.h"
+#include "model/DescribeRestoreTablesRequest.h"
+#include "model/DescribeRestoreTablesResult.h"
 #include "model/DescribeSecurityGroupsRequest.h"
 #include "model/DescribeSecurityGroupsResult.h"
+#include "model/EnableHBaseueBackupRequest.h"
+#include "model/EnableHBaseueBackupResult.h"
 #include "model/ListTagResourcesRequest.h"
 #include "model/ListTagResourcesResult.h"
 #include "model/ListTagsRequest.h"
 #include "model/ListTagsResult.h"
+#include "model/ModifyBackupPlanConfigRequest.h"
+#include "model/ModifyBackupPlanConfigResult.h"
 #include "model/ModifyClusterDeletionProtectionRequest.h"
 #include "model/ModifyClusterDeletionProtectionResult.h"
 #include "model/ModifyInstanceMaintainTimeRequest.h"
@@ -105,6 +127,9 @@ 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::CreateBackupPlanResult> CreateBackupPlanOutcome;
+			typedef std::future<CreateBackupPlanOutcome> CreateBackupPlanOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::CreateBackupPlanRequest&, const CreateBackupPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBackupPlanAsyncHandler;
 			typedef Outcome<Error, Model::CreateClusterResult> CreateClusterOutcome;
 			typedef std::future<CreateClusterOutcome> CreateClusterOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::CreateClusterRequest&, const CreateClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateClusterAsyncHandler;
@@ -114,6 +139,9 @@ namespace AlibabaCloud
 			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::CreateRestorePlanResult> CreateRestorePlanOutcome;
+			typedef std::future<CreateRestorePlanOutcome> CreateRestorePlanOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::CreateRestorePlanRequest&, const CreateRestorePlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRestorePlanAsyncHandler;
 			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;
@@ -123,6 +151,18 @@ namespace AlibabaCloud
 			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::DescribeBackupPlanConfigResult> DescribeBackupPlanConfigOutcome;
+			typedef std::future<DescribeBackupPlanConfigOutcome> DescribeBackupPlanConfigOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeBackupPlanConfigRequest&, const DescribeBackupPlanConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupPlanConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeBackupStatusResult> DescribeBackupStatusOutcome;
+			typedef std::future<DescribeBackupStatusOutcome> DescribeBackupStatusOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeBackupStatusRequest&, const DescribeBackupStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupStatusAsyncHandler;
+			typedef Outcome<Error, Model::DescribeBackupSummaryResult> DescribeBackupSummaryOutcome;
+			typedef std::future<DescribeBackupSummaryOutcome> DescribeBackupSummaryOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeBackupSummaryRequest&, const DescribeBackupSummaryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupSummaryAsyncHandler;
+			typedef Outcome<Error, Model::DescribeBackupTablesResult> DescribeBackupTablesOutcome;
+			typedef std::future<DescribeBackupTablesOutcome> DescribeBackupTablesOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeBackupTablesRequest&, const DescribeBackupTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupTablesAsyncHandler;
 			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;
@@ -141,18 +181,33 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeIpWhitelistResult> DescribeIpWhitelistOutcome;
 			typedef std::future<DescribeIpWhitelistOutcome> DescribeIpWhitelistOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::DescribeIpWhitelistRequest&, const DescribeIpWhitelistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeIpWhitelistAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRecoverableTimeRangeResult> DescribeRecoverableTimeRangeOutcome;
+			typedef std::future<DescribeRecoverableTimeRangeOutcome> DescribeRecoverableTimeRangeOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeRecoverableTimeRangeRequest&, const DescribeRecoverableTimeRangeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRecoverableTimeRangeAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
 			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRestoreSummaryResult> DescribeRestoreSummaryOutcome;
+			typedef std::future<DescribeRestoreSummaryOutcome> DescribeRestoreSummaryOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeRestoreSummaryRequest&, const DescribeRestoreSummaryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRestoreSummaryAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRestoreTablesResult> DescribeRestoreTablesOutcome;
+			typedef std::future<DescribeRestoreTablesOutcome> DescribeRestoreTablesOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::DescribeRestoreTablesRequest&, const DescribeRestoreTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRestoreTablesAsyncHandler;
 			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::EnableHBaseueBackupResult> EnableHBaseueBackupOutcome;
+			typedef std::future<EnableHBaseueBackupOutcome> EnableHBaseueBackupOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::EnableHBaseueBackupRequest&, const EnableHBaseueBackupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableHBaseueBackupAsyncHandler;
 			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::ListTagsResult> ListTagsOutcome;
 			typedef std::future<ListTagsOutcome> ListTagsOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::ListTagsRequest&, const ListTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagsAsyncHandler;
+			typedef Outcome<Error, Model::ModifyBackupPlanConfigResult> ModifyBackupPlanConfigOutcome;
+			typedef std::future<ModifyBackupPlanConfigOutcome> ModifyBackupPlanConfigOutcomeCallable;
+			typedef std::function<void(const HBaseClient*, const Model::ModifyBackupPlanConfigRequest&, const ModifyBackupPlanConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBackupPlanConfigAsyncHandler;
 			typedef Outcome<Error, Model::ModifyClusterDeletionProtectionResult> ModifyClusterDeletionProtectionOutcome;
 			typedef std::future<ModifyClusterDeletionProtectionOutcome> ModifyClusterDeletionProtectionOutcomeCallable;
 			typedef std::function<void(const HBaseClient*, const Model::ModifyClusterDeletionProtectionRequest&, const ModifyClusterDeletionProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyClusterDeletionProtectionAsyncHandler;
@@ -212,6 +267,9 @@ 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;
+			CreateBackupPlanOutcome createBackupPlan(const Model::CreateBackupPlanRequest &request)const;
+			void createBackupPlanAsync(const Model::CreateBackupPlanRequest& request, const CreateBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateBackupPlanOutcomeCallable createBackupPlanCallable(const Model::CreateBackupPlanRequest& request) const;
 			CreateClusterOutcome createCluster(const Model::CreateClusterRequest &request)const;
 			void createClusterAsync(const Model::CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateClusterOutcomeCallable createClusterCallable(const Model::CreateClusterRequest& request) const;
@@ -221,6 +279,9 @@ namespace AlibabaCloud
 			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;
+			CreateRestorePlanOutcome createRestorePlan(const Model::CreateRestorePlanRequest &request)const;
+			void createRestorePlanAsync(const Model::CreateRestorePlanRequest& request, const CreateRestorePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateRestorePlanOutcomeCallable createRestorePlanCallable(const Model::CreateRestorePlanRequest& 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;
@@ -230,6 +291,18 @@ namespace AlibabaCloud
 			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;
+			DescribeBackupPlanConfigOutcome describeBackupPlanConfig(const Model::DescribeBackupPlanConfigRequest &request)const;
+			void describeBackupPlanConfigAsync(const Model::DescribeBackupPlanConfigRequest& request, const DescribeBackupPlanConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeBackupPlanConfigOutcomeCallable describeBackupPlanConfigCallable(const Model::DescribeBackupPlanConfigRequest& request) const;
+			DescribeBackupStatusOutcome describeBackupStatus(const Model::DescribeBackupStatusRequest &request)const;
+			void describeBackupStatusAsync(const Model::DescribeBackupStatusRequest& request, const DescribeBackupStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeBackupStatusOutcomeCallable describeBackupStatusCallable(const Model::DescribeBackupStatusRequest& request) const;
+			DescribeBackupSummaryOutcome describeBackupSummary(const Model::DescribeBackupSummaryRequest &request)const;
+			void describeBackupSummaryAsync(const Model::DescribeBackupSummaryRequest& request, const DescribeBackupSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeBackupSummaryOutcomeCallable describeBackupSummaryCallable(const Model::DescribeBackupSummaryRequest& request) const;
+			DescribeBackupTablesOutcome describeBackupTables(const Model::DescribeBackupTablesRequest &request)const;
+			void describeBackupTablesAsync(const Model::DescribeBackupTablesRequest& request, const DescribeBackupTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeBackupTablesOutcomeCallable describeBackupTablesCallable(const Model::DescribeBackupTablesRequest& 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;
@@ -248,18 +321,33 @@ namespace AlibabaCloud
 			DescribeIpWhitelistOutcome describeIpWhitelist(const Model::DescribeIpWhitelistRequest &request)const;
 			void describeIpWhitelistAsync(const Model::DescribeIpWhitelistRequest& request, const DescribeIpWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeIpWhitelistOutcomeCallable describeIpWhitelistCallable(const Model::DescribeIpWhitelistRequest& request) const;
+			DescribeRecoverableTimeRangeOutcome describeRecoverableTimeRange(const Model::DescribeRecoverableTimeRangeRequest &request)const;
+			void describeRecoverableTimeRangeAsync(const Model::DescribeRecoverableTimeRangeRequest& request, const DescribeRecoverableTimeRangeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRecoverableTimeRangeOutcomeCallable describeRecoverableTimeRangeCallable(const Model::DescribeRecoverableTimeRangeRequest& request) const;
 			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
 			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			DescribeRestoreSummaryOutcome describeRestoreSummary(const Model::DescribeRestoreSummaryRequest &request)const;
+			void describeRestoreSummaryAsync(const Model::DescribeRestoreSummaryRequest& request, const DescribeRestoreSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRestoreSummaryOutcomeCallable describeRestoreSummaryCallable(const Model::DescribeRestoreSummaryRequest& request) const;
+			DescribeRestoreTablesOutcome describeRestoreTables(const Model::DescribeRestoreTablesRequest &request)const;
+			void describeRestoreTablesAsync(const Model::DescribeRestoreTablesRequest& request, const DescribeRestoreTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRestoreTablesOutcomeCallable describeRestoreTablesCallable(const Model::DescribeRestoreTablesRequest& request) const;
 			DescribeSecurityGroupsOutcome describeSecurityGroups(const Model::DescribeSecurityGroupsRequest &request)const;
 			void describeSecurityGroupsAsync(const Model::DescribeSecurityGroupsRequest& request, const DescribeSecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeSecurityGroupsOutcomeCallable describeSecurityGroupsCallable(const Model::DescribeSecurityGroupsRequest& request) const;
+			EnableHBaseueBackupOutcome enableHBaseueBackup(const Model::EnableHBaseueBackupRequest &request)const;
+			void enableHBaseueBackupAsync(const Model::EnableHBaseueBackupRequest& request, const EnableHBaseueBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableHBaseueBackupOutcomeCallable enableHBaseueBackupCallable(const Model::EnableHBaseueBackupRequest& 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;
 			ListTagsOutcome listTags(const Model::ListTagsRequest &request)const;
 			void listTagsAsync(const Model::ListTagsRequest& request, const ListTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTagsOutcomeCallable listTagsCallable(const Model::ListTagsRequest& request) const;
+			ModifyBackupPlanConfigOutcome modifyBackupPlanConfig(const Model::ModifyBackupPlanConfigRequest &request)const;
+			void modifyBackupPlanConfigAsync(const Model::ModifyBackupPlanConfigRequest& request, const ModifyBackupPlanConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyBackupPlanConfigOutcomeCallable modifyBackupPlanConfigCallable(const Model::ModifyBackupPlanConfigRequest& request) const;
 			ModifyClusterDeletionProtectionOutcome modifyClusterDeletionProtection(const Model::ModifyClusterDeletionProtectionRequest &request)const;
 			void modifyClusterDeletionProtectionAsync(const Model::ModifyClusterDeletionProtectionRequest& request, const ModifyClusterDeletionProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyClusterDeletionProtectionOutcomeCallable modifyClusterDeletionProtectionCallable(const Model::ModifyClusterDeletionProtectionRequest& request) const;

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

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

hbase/include/alibabacloud/hbase/model/CreateRestorePlanRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_CREATERESTOREPLANREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_CREATERESTOREPLANREQUEST_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 CreateRestorePlanRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateRestorePlanRequest();
+				~CreateRestorePlanRequest();
+
+				std::string getRestoreToDate()const;
+				void setRestoreToDate(const std::string& restoreToDate);
+				std::string getTables()const;
+				void setTables(const std::string& tables);
+				bool getRestoreByCopy()const;
+				void setRestoreByCopy(bool restoreByCopy);
+				bool getRestoreAllTable()const;
+				void setRestoreAllTable(bool restoreAllTable);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getTargetClusterId()const;
+				void setTargetClusterId(const std::string& targetClusterId);
+
+            private:
+				std::string restoreToDate_;
+				std::string tables_;
+				bool restoreByCopy_;
+				bool restoreAllTable_;
+				std::string clusterId_;
+				std::string targetClusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_CREATERESTOREPLANREQUEST_H_

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

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

hbase/include/alibabacloud/hbase/model/DescribeBackupPlanConfigResult.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_DESCRIBEBACKUPPLANCONFIGRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEBACKUPPLANCONFIGRESULT_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 DescribeBackupPlanConfigResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeBackupPlanConfigResult();
+				explicit DescribeBackupPlanConfigResult(const std::string &payload);
+				~DescribeBackupPlanConfigResult();
+				int getFullBackupCycle()const;
+				std::string getNextFullBackupDate()const;
+				std::vector<std::string> getTables()const;
+				int getMinHFileBackupCount()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int fullBackupCycle_;
+				std::string nextFullBackupDate_;
+				std::vector<std::string> tables_;
+				int minHFileBackupCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEBACKUPPLANCONFIGRESULT_H_

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

hbase/include/alibabacloud/hbase/model/DescribeBackupStatusResult.h

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

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

hbase/include/alibabacloud/hbase/model/DescribeBackupSummaryResult.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEBACKUPSUMMARYRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEBACKUPSUMMARYRESULT_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 DescribeBackupSummaryResult : public ServiceResult
+			{
+			public:
+				struct Incr
+				{
+					std::string status;
+					std::string speed;
+					std::string pos;
+					std::string backupLogSize;
+					std::string queueLogNum;
+					std::string runningLogNum;
+				};
+				struct Full
+				{
+					struct Record
+					{
+						std::string status;
+						std::string speed;
+						std::string finishTime;
+						std::string createTime;
+						std::string dataSize;
+						std::string process;
+						std::string recordId;
+					};
+					std::string hasMore;
+					std::string nextFullBackupDate;
+					std::vector<Record> records;
+					std::string recordSize;
+				};
+
+
+				DescribeBackupSummaryResult();
+				explicit DescribeBackupSummaryResult(const std::string &payload);
+				~DescribeBackupSummaryResult();
+				Incr getIncr()const;
+				Full getFull()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Incr incr_;
+				Full full_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEBACKUPSUMMARYRESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeBackupTablesRequest.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_DESCRIBEBACKUPTABLESREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEBACKUPTABLESREQUEST_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 DescribeBackupTablesRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeBackupTablesRequest();
+				~DescribeBackupTablesRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getBackupRecordId()const;
+				void setBackupRecordId(const std::string& backupRecordId);
+
+            private:
+				std::string clusterId_;
+				std::string backupRecordId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEBACKUPTABLESREQUEST_H_

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

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

@@ -42,11 +42,13 @@ namespace AlibabaCloud
 				DescribeInstanceResult();
 				explicit DescribeInstanceResult(const std::string &payload);
 				~DescribeInstanceResult();
+				std::string getModuleStackVersion()const;
 				bool getIsHa()const;
 				std::string getCreatedTime()const;
 				std::string getMasterInstanceType()const;
 				bool getIsDeletionProtection()const;
 				bool getIsLatestVersion()const;
+				int getModuleId()const;
 				std::string getMaintainEndTime()const;
 				std::string getNetworkType()const;
 				std::string getCoreInstanceType()const;
@@ -58,6 +60,7 @@ namespace AlibabaCloud
 				std::string getStatus()const;
 				std::string getMajorVersion()const;
 				std::string getCoreDiskCount()const;
+				std::string getParentId()const;
 				int getMasterDiskSize()const;
 				std::string getExpireTimeUTC()const;
 				std::string getZoneId()const;
@@ -83,11 +86,13 @@ namespace AlibabaCloud
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string moduleStackVersion_;
 				bool isHa_;
 				std::string createdTime_;
 				std::string masterInstanceType_;
 				bool isDeletionProtection_;
 				bool isLatestVersion_;
+				int moduleId_;
 				std::string maintainEndTime_;
 				std::string networkType_;
 				std::string coreInstanceType_;
@@ -99,6 +104,7 @@ namespace AlibabaCloud
 				std::string status_;
 				std::string majorVersion_;
 				std::string coreDiskCount_;
+				std::string parentId_;
 				int masterDiskSize_;
 				std::string expireTimeUTC_;
 				std::string zoneId_;

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

@@ -39,10 +39,12 @@ namespace AlibabaCloud
 						std::string value;
 						std::string key;
 					};
+					std::string moduleStackVersion;
 					bool isHa;
 					std::string createdTime;
 					std::string masterInstanceType;
 					bool isDeletionProtection;
+					int moduleId;
 					std::string networkType;
 					std::string coreInstanceType;
 					std::string clusterName;
@@ -51,6 +53,7 @@ namespace AlibabaCloud
 					std::string engine;
 					std::string status;
 					std::string majorVersion;
+					std::string parentId;
 					int masterDiskSize;
 					std::string expireTimeUTC;
 					std::string zoneId;

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

hbase/include/alibabacloud/hbase/model/DescribeRecoverableTimeRangeResult.h

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

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

hbase/include/alibabacloud/hbase/model/DescribeRestoreSummaryResult.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBERESTORESUMMARYRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBERESTORESUMMARYRESULT_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 DescribeRestoreSummaryResult : public ServiceResult
+			{
+			public:
+				struct Rescord
+				{
+					std::string status;
+					std::string logProcess;
+					std::string finishTime;
+					std::string schemaProcess;
+					std::string createTime;
+					std::string recordId;
+					std::string bulkLoadProcess;
+					std::string hfileRestoreProcess;
+				};
+
+
+				DescribeRestoreSummaryResult();
+				explicit DescribeRestoreSummaryResult(const std::string &payload);
+				~DescribeRestoreSummaryResult();
+				int getRestoreRecordSize()const;
+				int getHasMoreRestoreRecord()const;
+				std::vector<Rescord> getRescords()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int restoreRecordSize_;
+				int hasMoreRestoreRecord_;
+				std::vector<Rescord> rescords_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBERESTORESUMMARYRESULT_H_

hbase/include/alibabacloud/hbase/model/DescribeRestoreTablesRequest.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_DESCRIBERESTORETABLESREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBERESTORETABLESREQUEST_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 DescribeRestoreTablesRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRestoreTablesRequest();
+				~DescribeRestoreTablesRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getRestoreRecordId()const;
+				void setRestoreRecordId(const std::string& restoreRecordId);
+
+            private:
+				std::string clusterId_;
+				std::string restoreRecordId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBERESTORETABLESREQUEST_H_

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

hbase/include/alibabacloud/hbase/model/EnableHBaseueBackupRequest.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_ENABLEHBASEUEBACKUPREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEBACKUPREQUEST_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 EnableHBaseueBackupRequest : public RpcServiceRequest
+			{
+
+			public:
+				EnableHBaseueBackupRequest();
+				~EnableHBaseueBackupRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getHbaseueClusterId()const;
+				void setHbaseueClusterId(const std::string& hbaseueClusterId);
+				int getColdStorageSize()const;
+				void setColdStorageSize(int coldStorageSize);
+				int getNodeCount()const;
+				void setNodeCount(int nodeCount);
+
+            private:
+				std::string clientToken_;
+				std::string hbaseueClusterId_;
+				int coldStorageSize_;
+				int nodeCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_ENABLEHBASEUEBACKUPREQUEST_H_

hbase/include/alibabacloud/hbase/model/EnableHBaseueBackupResult.h

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

hbase/include/alibabacloud/hbase/model/ModifyBackupPlanConfigRequest.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_MODIFYBACKUPPLANCONFIGREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_MODIFYBACKUPPLANCONFIGREQUEST_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 ModifyBackupPlanConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyBackupPlanConfigRequest();
+				~ModifyBackupPlanConfigRequest();
+
+				std::string getFullBackupCycle()const;
+				void setFullBackupCycle(const std::string& fullBackupCycle);
+				std::string getTables()const;
+				void setTables(const std::string& tables);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getMinHFileBackupCount()const;
+				void setMinHFileBackupCount(const std::string& minHFileBackupCount);
+				std::string getNextFullBackupDate()const;
+				void setNextFullBackupDate(const std::string& nextFullBackupDate);
+
+            private:
+				std::string fullBackupCycle_;
+				std::string tables_;
+				std::string clusterId_;
+				std::string minHFileBackupCount_;
+				std::string nextFullBackupDate_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYBACKUPPLANCONFIGREQUEST_H_

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

hbase/src/HBaseClient.cc

@@ -123,6 +123,42 @@ HBaseClient::ConvertInstanceOutcomeCallable HBaseClient::convertInstanceCallable
 	return task->get_future();
 }
 
+HBaseClient::CreateBackupPlanOutcome HBaseClient::createBackupPlan(const CreateBackupPlanRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateBackupPlanOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateBackupPlanOutcome(CreateBackupPlanResult(outcome.result()));
+	else
+		return CreateBackupPlanOutcome(outcome.error());
+}
+
+void HBaseClient::createBackupPlanAsync(const CreateBackupPlanRequest& request, const CreateBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createBackupPlan(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::CreateBackupPlanOutcomeCallable HBaseClient::createBackupPlanCallable(const CreateBackupPlanRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateBackupPlanOutcome()>>(
+			[this, request]()
+			{
+			return this->createBackupPlan(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::CreateClusterOutcome HBaseClient::createCluster(const CreateClusterRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +267,42 @@ HBaseClient::CreateInstanceOutcomeCallable HBaseClient::createInstanceCallable(c
 	return task->get_future();
 }
 
+HBaseClient::CreateRestorePlanOutcome HBaseClient::createRestorePlan(const CreateRestorePlanRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateRestorePlanOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateRestorePlanOutcome(CreateRestorePlanResult(outcome.result()));
+	else
+		return CreateRestorePlanOutcome(outcome.error());
+}
+
+void HBaseClient::createRestorePlanAsync(const CreateRestorePlanRequest& request, const CreateRestorePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createRestorePlan(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::CreateRestorePlanOutcomeCallable HBaseClient::createRestorePlanCallable(const CreateRestorePlanRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateRestorePlanOutcome()>>(
+			[this, request]()
+			{
+			return this->createRestorePlan(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DeleteHbaseHaSlbOutcome HBaseClient::deleteHbaseHaSlb(const DeleteHbaseHaSlbRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +411,150 @@ HBaseClient::DeleteUserHdfsInfoOutcomeCallable HBaseClient::deleteUserHdfsInfoCa
 	return task->get_future();
 }
 
+HBaseClient::DescribeBackupPlanConfigOutcome HBaseClient::describeBackupPlanConfig(const DescribeBackupPlanConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeBackupPlanConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeBackupPlanConfigOutcome(DescribeBackupPlanConfigResult(outcome.result()));
+	else
+		return DescribeBackupPlanConfigOutcome(outcome.error());
+}
+
+void HBaseClient::describeBackupPlanConfigAsync(const DescribeBackupPlanConfigRequest& request, const DescribeBackupPlanConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeBackupPlanConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeBackupPlanConfigOutcomeCallable HBaseClient::describeBackupPlanConfigCallable(const DescribeBackupPlanConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeBackupPlanConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->describeBackupPlanConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeBackupStatusOutcome HBaseClient::describeBackupStatus(const DescribeBackupStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeBackupStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeBackupStatusOutcome(DescribeBackupStatusResult(outcome.result()));
+	else
+		return DescribeBackupStatusOutcome(outcome.error());
+}
+
+void HBaseClient::describeBackupStatusAsync(const DescribeBackupStatusRequest& request, const DescribeBackupStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeBackupStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeBackupStatusOutcomeCallable HBaseClient::describeBackupStatusCallable(const DescribeBackupStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeBackupStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->describeBackupStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeBackupSummaryOutcome HBaseClient::describeBackupSummary(const DescribeBackupSummaryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeBackupSummaryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeBackupSummaryOutcome(DescribeBackupSummaryResult(outcome.result()));
+	else
+		return DescribeBackupSummaryOutcome(outcome.error());
+}
+
+void HBaseClient::describeBackupSummaryAsync(const DescribeBackupSummaryRequest& request, const DescribeBackupSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeBackupSummary(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeBackupSummaryOutcomeCallable HBaseClient::describeBackupSummaryCallable(const DescribeBackupSummaryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeBackupSummaryOutcome()>>(
+			[this, request]()
+			{
+			return this->describeBackupSummary(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeBackupTablesOutcome HBaseClient::describeBackupTables(const DescribeBackupTablesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeBackupTablesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeBackupTablesOutcome(DescribeBackupTablesResult(outcome.result()));
+	else
+		return DescribeBackupTablesOutcome(outcome.error());
+}
+
+void HBaseClient::describeBackupTablesAsync(const DescribeBackupTablesRequest& request, const DescribeBackupTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeBackupTables(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeBackupTablesOutcomeCallable HBaseClient::describeBackupTablesCallable(const DescribeBackupTablesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeBackupTablesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeBackupTables(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DescribeDBInstanceUsageOutcome HBaseClient::describeDBInstanceUsage(const DescribeDBInstanceUsageRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,6 +771,42 @@ HBaseClient::DescribeIpWhitelistOutcomeCallable HBaseClient::describeIpWhitelist
 	return task->get_future();
 }
 
+HBaseClient::DescribeRecoverableTimeRangeOutcome HBaseClient::describeRecoverableTimeRange(const DescribeRecoverableTimeRangeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRecoverableTimeRangeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRecoverableTimeRangeOutcome(DescribeRecoverableTimeRangeResult(outcome.result()));
+	else
+		return DescribeRecoverableTimeRangeOutcome(outcome.error());
+}
+
+void HBaseClient::describeRecoverableTimeRangeAsync(const DescribeRecoverableTimeRangeRequest& request, const DescribeRecoverableTimeRangeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRecoverableTimeRange(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeRecoverableTimeRangeOutcomeCallable HBaseClient::describeRecoverableTimeRangeCallable(const DescribeRecoverableTimeRangeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRecoverableTimeRangeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRecoverableTimeRange(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DescribeRegionsOutcome HBaseClient::describeRegions(const DescribeRegionsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -591,6 +843,78 @@ HBaseClient::DescribeRegionsOutcomeCallable HBaseClient::describeRegionsCallable
 	return task->get_future();
 }
 
+HBaseClient::DescribeRestoreSummaryOutcome HBaseClient::describeRestoreSummary(const DescribeRestoreSummaryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRestoreSummaryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRestoreSummaryOutcome(DescribeRestoreSummaryResult(outcome.result()));
+	else
+		return DescribeRestoreSummaryOutcome(outcome.error());
+}
+
+void HBaseClient::describeRestoreSummaryAsync(const DescribeRestoreSummaryRequest& request, const DescribeRestoreSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRestoreSummary(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeRestoreSummaryOutcomeCallable HBaseClient::describeRestoreSummaryCallable(const DescribeRestoreSummaryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRestoreSummaryOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRestoreSummary(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HBaseClient::DescribeRestoreTablesOutcome HBaseClient::describeRestoreTables(const DescribeRestoreTablesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRestoreTablesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRestoreTablesOutcome(DescribeRestoreTablesResult(outcome.result()));
+	else
+		return DescribeRestoreTablesOutcome(outcome.error());
+}
+
+void HBaseClient::describeRestoreTablesAsync(const DescribeRestoreTablesRequest& request, const DescribeRestoreTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRestoreTables(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::DescribeRestoreTablesOutcomeCallable HBaseClient::describeRestoreTablesCallable(const DescribeRestoreTablesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRestoreTablesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRestoreTables(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::DescribeSecurityGroupsOutcome HBaseClient::describeSecurityGroups(const DescribeSecurityGroupsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -627,6 +951,42 @@ HBaseClient::DescribeSecurityGroupsOutcomeCallable HBaseClient::describeSecurity
 	return task->get_future();
 }
 
+HBaseClient::EnableHBaseueBackupOutcome HBaseClient::enableHBaseueBackup(const EnableHBaseueBackupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableHBaseueBackupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableHBaseueBackupOutcome(EnableHBaseueBackupResult(outcome.result()));
+	else
+		return EnableHBaseueBackupOutcome(outcome.error());
+}
+
+void HBaseClient::enableHBaseueBackupAsync(const EnableHBaseueBackupRequest& request, const EnableHBaseueBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableHBaseueBackup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::EnableHBaseueBackupOutcomeCallable HBaseClient::enableHBaseueBackupCallable(const EnableHBaseueBackupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableHBaseueBackupOutcome()>>(
+			[this, request]()
+			{
+			return this->enableHBaseueBackup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::ListTagResourcesOutcome HBaseClient::listTagResources(const ListTagResourcesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -699,6 +1059,42 @@ HBaseClient::ListTagsOutcomeCallable HBaseClient::listTagsCallable(const ListTag
 	return task->get_future();
 }
 
+HBaseClient::ModifyBackupPlanConfigOutcome HBaseClient::modifyBackupPlanConfig(const ModifyBackupPlanConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyBackupPlanConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyBackupPlanConfigOutcome(ModifyBackupPlanConfigResult(outcome.result()));
+	else
+		return ModifyBackupPlanConfigOutcome(outcome.error());
+}
+
+void HBaseClient::modifyBackupPlanConfigAsync(const ModifyBackupPlanConfigRequest& request, const ModifyBackupPlanConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyBackupPlanConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HBaseClient::ModifyBackupPlanConfigOutcomeCallable HBaseClient::modifyBackupPlanConfigCallable(const ModifyBackupPlanConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyBackupPlanConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyBackupPlanConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HBaseClient::ModifyClusterDeletionProtectionOutcome HBaseClient::modifyClusterDeletionProtection(const ModifyClusterDeletionProtectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

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

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

hbase/src/model/CreateRestorePlanRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/CreateRestorePlanRequest.h>
+
+using AlibabaCloud::HBase::Model::CreateRestorePlanRequest;
+
+CreateRestorePlanRequest::CreateRestorePlanRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "CreateRestorePlan")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateRestorePlanRequest::~CreateRestorePlanRequest()
+{}
+
+std::string CreateRestorePlanRequest::getRestoreToDate()const
+{
+	return restoreToDate_;
+}
+
+void CreateRestorePlanRequest::setRestoreToDate(const std::string& restoreToDate)
+{
+	restoreToDate_ = restoreToDate;
+	setParameter("RestoreToDate", restoreToDate);
+}
+
+std::string CreateRestorePlanRequest::getTables()const
+{
+	return tables_;
+}
+
+void CreateRestorePlanRequest::setTables(const std::string& tables)
+{
+	tables_ = tables;
+	setParameter("Tables", tables);
+}
+
+bool CreateRestorePlanRequest::getRestoreByCopy()const
+{
+	return restoreByCopy_;
+}
+
+void CreateRestorePlanRequest::setRestoreByCopy(bool restoreByCopy)
+{
+	restoreByCopy_ = restoreByCopy;
+	setParameter("RestoreByCopy", restoreByCopy ? "true" : "false");
+}
+
+bool CreateRestorePlanRequest::getRestoreAllTable()const
+{
+	return restoreAllTable_;
+}
+
+void CreateRestorePlanRequest::setRestoreAllTable(bool restoreAllTable)
+{
+	restoreAllTable_ = restoreAllTable;
+	setParameter("RestoreAllTable", restoreAllTable ? "true" : "false");
+}
+
+std::string CreateRestorePlanRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void CreateRestorePlanRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string CreateRestorePlanRequest::getTargetClusterId()const
+{
+	return targetClusterId_;
+}
+
+void CreateRestorePlanRequest::setTargetClusterId(const std::string& targetClusterId)
+{
+	targetClusterId_ = targetClusterId;
+	setParameter("TargetClusterId", targetClusterId);
+}
+

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

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

hbase/src/model/DescribeBackupPlanConfigResult.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/DescribeBackupPlanConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeBackupPlanConfigResult::DescribeBackupPlanConfigResult() :
+	ServiceResult()
+{}
+
+DescribeBackupPlanConfigResult::DescribeBackupPlanConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeBackupPlanConfigResult::~DescribeBackupPlanConfigResult()
+{}
+
+void DescribeBackupPlanConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTables = value["Tables"]["Table"];
+	for (const auto &item : allTables)
+		tables_.push_back(item.asString());
+	if(!value["FullBackupCycle"].isNull())
+		fullBackupCycle_ = std::stoi(value["FullBackupCycle"].asString());
+	if(!value["MinHFileBackupCount"].isNull())
+		minHFileBackupCount_ = std::stoi(value["MinHFileBackupCount"].asString());
+	if(!value["NextFullBackupDate"].isNull())
+		nextFullBackupDate_ = value["NextFullBackupDate"].asString();
+
+}
+
+int DescribeBackupPlanConfigResult::getFullBackupCycle()const
+{
+	return fullBackupCycle_;
+}
+
+std::string DescribeBackupPlanConfigResult::getNextFullBackupDate()const
+{
+	return nextFullBackupDate_;
+}
+
+std::vector<std::string> DescribeBackupPlanConfigResult::getTables()const
+{
+	return tables_;
+}
+
+int DescribeBackupPlanConfigResult::getMinHFileBackupCount()const
+{
+	return minHFileBackupCount_;
+}
+

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

hbase/src/model/DescribeBackupStatusResult.cc

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

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

hbase/src/model/DescribeBackupSummaryResult.cc

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeBackupSummaryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeBackupSummaryResult::DescribeBackupSummaryResult() :
+	ServiceResult()
+{}
+
+DescribeBackupSummaryResult::DescribeBackupSummaryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeBackupSummaryResult::~DescribeBackupSummaryResult()
+{}
+
+void DescribeBackupSummaryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto incrNode = value["Incr"];
+	if(!incrNode["Pos"].isNull())
+		incr_.pos = incrNode["Pos"].asString();
+	if(!incrNode["QueueLogNum"].isNull())
+		incr_.queueLogNum = incrNode["QueueLogNum"].asString();
+	if(!incrNode["Speed"].isNull())
+		incr_.speed = incrNode["Speed"].asString();
+	if(!incrNode["Status"].isNull())
+		incr_.status = incrNode["Status"].asString();
+	if(!incrNode["RunningLogNum"].isNull())
+		incr_.runningLogNum = incrNode["RunningLogNum"].asString();
+	if(!incrNode["BackupLogSize"].isNull())
+		incr_.backupLogSize = incrNode["BackupLogSize"].asString();
+	auto fullNode = value["Full"];
+	if(!fullNode["HasMore"].isNull())
+		full_.hasMore = fullNode["HasMore"].asString();
+	if(!fullNode["RecordSize"].isNull())
+		full_.recordSize = fullNode["RecordSize"].asString();
+	if(!fullNode["NextFullBackupDate"].isNull())
+		full_.nextFullBackupDate = fullNode["NextFullBackupDate"].asString();
+	auto allRecordsNode = fullNode["Records"]["Record"];
+	for (auto fullNodeRecordsRecord : allRecordsNode)
+	{
+		Full::Record recordObject;
+		if(!fullNodeRecordsRecord["RecordId"].isNull())
+			recordObject.recordId = fullNodeRecordsRecord["RecordId"].asString();
+		if(!fullNodeRecordsRecord["FinishTime"].isNull())
+			recordObject.finishTime = fullNodeRecordsRecord["FinishTime"].asString();
+		if(!fullNodeRecordsRecord["Process"].isNull())
+			recordObject.process = fullNodeRecordsRecord["Process"].asString();
+		if(!fullNodeRecordsRecord["CreateTime"].isNull())
+			recordObject.createTime = fullNodeRecordsRecord["CreateTime"].asString();
+		if(!fullNodeRecordsRecord["DataSize"].isNull())
+			recordObject.dataSize = fullNodeRecordsRecord["DataSize"].asString();
+		if(!fullNodeRecordsRecord["Speed"].isNull())
+			recordObject.speed = fullNodeRecordsRecord["Speed"].asString();
+		if(!fullNodeRecordsRecord["Status"].isNull())
+			recordObject.status = fullNodeRecordsRecord["Status"].asString();
+		full_.records.push_back(recordObject);
+	}
+
+}
+
+DescribeBackupSummaryResult::Incr DescribeBackupSummaryResult::getIncr()const
+{
+	return incr_;
+}
+
+DescribeBackupSummaryResult::Full DescribeBackupSummaryResult::getFull()const
+{
+	return full_;
+}
+

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

hbase/src/model/DescribeBackupTablesResult.cc

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

hbase/src/model/DescribeInstanceResult.cc

@@ -121,9 +121,20 @@ void DescribeInstanceResult::parse(const std::string &payload)
 		clusterName_ = value["ClusterName"].asString();
 	if(!value["IsDeletionProtection"].isNull())
 		isDeletionProtection_ = value["IsDeletionProtection"].asString() == "true";
+	if(!value["ParentId"].isNull())
+		parentId_ = value["ParentId"].asString();
+	if(!value["ModuleId"].isNull())
+		moduleId_ = std::stoi(value["ModuleId"].asString());
+	if(!value["ModuleStackVersion"].isNull())
+		moduleStackVersion_ = value["ModuleStackVersion"].asString();
 
 }
 
+std::string DescribeInstanceResult::getModuleStackVersion()const
+{
+	return moduleStackVersion_;
+}
+
 bool DescribeInstanceResult::getIsHa()const
 {
 	return isHa_;
@@ -149,6 +160,11 @@ bool DescribeInstanceResult::getIsLatestVersion()const
 	return isLatestVersion_;
 }
 
+int DescribeInstanceResult::getModuleId()const
+{
+	return moduleId_;
+}
+
 std::string DescribeInstanceResult::getMaintainEndTime()const
 {
 	return maintainEndTime_;
@@ -204,6 +220,11 @@ std::string DescribeInstanceResult::getCoreDiskCount()const
 	return coreDiskCount_;
 }
 
+std::string DescribeInstanceResult::getParentId()const
+{
+	return parentId_;
+}
+
 int DescribeInstanceResult::getMasterDiskSize()const
 {
 	return masterDiskSize_;

hbase/src/model/DescribeInstancesResult.cc

@@ -103,6 +103,12 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.clusterName = valueInstancesInstance["ClusterName"].asString();
 		if(!valueInstancesInstance["IsDeletionProtection"].isNull())
 			instancesObject.isDeletionProtection = valueInstancesInstance["IsDeletionProtection"].asString() == "true";
+		if(!valueInstancesInstance["ParentId"].isNull())
+			instancesObject.parentId = valueInstancesInstance["ParentId"].asString();
+		if(!valueInstancesInstance["ModuleId"].isNull())
+			instancesObject.moduleId = std::stoi(valueInstancesInstance["ModuleId"].asString());
+		if(!valueInstancesInstance["ModuleStackVersion"].isNull())
+			instancesObject.moduleStackVersion = valueInstancesInstance["ModuleStackVersion"].asString();
 		auto allTagsNode = allInstancesNode["Tags"]["Tag"];
 		for (auto allInstancesNodeTagsTag : allTagsNode)
 		{

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

hbase/src/model/DescribeRecoverableTimeRangeResult.cc

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

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

hbase/src/model/DescribeRestoreSummaryResult.cc

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeRestoreSummaryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeRestoreSummaryResult::DescribeRestoreSummaryResult() :
+	ServiceResult()
+{}
+
+DescribeRestoreSummaryResult::DescribeRestoreSummaryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRestoreSummaryResult::~DescribeRestoreSummaryResult()
+{}
+
+void DescribeRestoreSummaryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRescordsNode = value["Rescords"]["Rescord"];
+	for (auto valueRescordsRescord : allRescordsNode)
+	{
+		Rescord rescordsObject;
+		if(!valueRescordsRescord["RecordId"].isNull())
+			rescordsObject.recordId = valueRescordsRescord["RecordId"].asString();
+		if(!valueRescordsRescord["FinishTime"].isNull())
+			rescordsObject.finishTime = valueRescordsRescord["FinishTime"].asString();
+		if(!valueRescordsRescord["SchemaProcess"].isNull())
+			rescordsObject.schemaProcess = valueRescordsRescord["SchemaProcess"].asString();
+		if(!valueRescordsRescord["HfileRestoreProcess"].isNull())
+			rescordsObject.hfileRestoreProcess = valueRescordsRescord["HfileRestoreProcess"].asString();
+		if(!valueRescordsRescord["CreateTime"].isNull())
+			rescordsObject.createTime = valueRescordsRescord["CreateTime"].asString();
+		if(!valueRescordsRescord["BulkLoadProcess"].isNull())
+			rescordsObject.bulkLoadProcess = valueRescordsRescord["BulkLoadProcess"].asString();
+		if(!valueRescordsRescord["Status"].isNull())
+			rescordsObject.status = valueRescordsRescord["Status"].asString();
+		if(!valueRescordsRescord["LogProcess"].isNull())
+			rescordsObject.logProcess = valueRescordsRescord["LogProcess"].asString();
+		rescords_.push_back(rescordsObject);
+	}
+	if(!value["RestoreRecordSize"].isNull())
+		restoreRecordSize_ = std::stoi(value["RestoreRecordSize"].asString());
+	if(!value["HasMoreRestoreRecord"].isNull())
+		hasMoreRestoreRecord_ = std::stoi(value["HasMoreRestoreRecord"].asString());
+
+}
+
+int DescribeRestoreSummaryResult::getRestoreRecordSize()const
+{
+	return restoreRecordSize_;
+}
+
+int DescribeRestoreSummaryResult::getHasMoreRestoreRecord()const
+{
+	return hasMoreRestoreRecord_;
+}
+
+std::vector<DescribeRestoreSummaryResult::Rescord> DescribeRestoreSummaryResult::getRescords()const
+{
+	return rescords_;
+}
+

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

hbase/src/model/DescribeRestoreTablesResult.cc

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

hbase/src/model/EnableHBaseueBackupRequest.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/EnableHBaseueBackupRequest.h>
+
+using AlibabaCloud::HBase::Model::EnableHBaseueBackupRequest;
+
+EnableHBaseueBackupRequest::EnableHBaseueBackupRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "EnableHBaseueBackup")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+EnableHBaseueBackupRequest::~EnableHBaseueBackupRequest()
+{}
+
+std::string EnableHBaseueBackupRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void EnableHBaseueBackupRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string EnableHBaseueBackupRequest::getHbaseueClusterId()const
+{
+	return hbaseueClusterId_;
+}
+
+void EnableHBaseueBackupRequest::setHbaseueClusterId(const std::string& hbaseueClusterId)
+{
+	hbaseueClusterId_ = hbaseueClusterId;
+	setParameter("HbaseueClusterId", hbaseueClusterId);
+}
+
+int EnableHBaseueBackupRequest::getColdStorageSize()const
+{
+	return coldStorageSize_;
+}
+
+void EnableHBaseueBackupRequest::setColdStorageSize(int coldStorageSize)
+{
+	coldStorageSize_ = coldStorageSize;
+	setParameter("ColdStorageSize", std::to_string(coldStorageSize));
+}
+
+int EnableHBaseueBackupRequest::getNodeCount()const
+{
+	return nodeCount_;
+}
+
+void EnableHBaseueBackupRequest::setNodeCount(int nodeCount)
+{
+	nodeCount_ = nodeCount;
+	setParameter("NodeCount", std::to_string(nodeCount));
+}
+

hbase/src/model/EnableHBaseueBackupResult.cc

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

hbase/src/model/ModifyBackupPlanConfigRequest.cc

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

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