1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

regenerate code

Browse Source
This commit is contained in:
wb-hx510875
2020-03-26 17:27:13 +08:00
committed by Axios
parent cba94f2119
commit f0c2600a26
6249 changed files with 188711 additions and 43443 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
hbase/include/alibabacloud/hbase/HBaseClient.h
View File

@@ -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;

48
hbase/include/alibabacloud/hbase/model/CreateBackupPlanRequest.h Normal file
View File

@@ -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_

49
hbase/include/alibabacloud/hbase/model/CreateBackupPlanResult.h Normal file
View File

@@ -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_

63
hbase/include/alibabacloud/hbase/model/CreateRestorePlanRequest.h Normal file
View File

@@ -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_

49
hbase/include/alibabacloud/hbase/model/CreateRestorePlanResult.h Normal file
View File

@@ -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_

48
hbase/include/alibabacloud/hbase/model/DescribeBackupPlanConfigRequest.h Normal file
View File

@@ -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_

57
hbase/include/alibabacloud/hbase/model/DescribeBackupPlanConfigResult.h Normal file
View File

@@ -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_

48
hbase/include/alibabacloud/hbase/model/DescribeBackupStatusRequest.h Normal file
View File

@@ -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_

55
hbase/include/alibabacloud/hbase/model/DescribeBackupStatusResult.h Normal file
View File

@@ -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_

48
hbase/include/alibabacloud/hbase/model/DescribeBackupSummaryRequest.h Normal file
View File

@@ -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_

79
hbase/include/alibabacloud/hbase/model/DescribeBackupSummaryResult.h Normal file
View File

@@ -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_

51
hbase/include/alibabacloud/hbase/model/DescribeBackupTablesRequest.h Normal file
View File

@@ -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_

51
hbase/include/alibabacloud/hbase/model/DescribeBackupTablesResult.h Normal file
View File

@@ -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_

6
hbase/include/alibabacloud/hbase/model/DescribeInstanceResult.h
View File

@@ -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_;

3
hbase/include/alibabacloud/hbase/model/DescribeInstancesResult.h
View File

@@ -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;

48
hbase/include/alibabacloud/hbase/model/DescribeRecoverableTimeRangeRequest.h Normal file
View File

@@ -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_

53
hbase/include/alibabacloud/hbase/model/DescribeRecoverableTimeRangeResult.h Normal file
View File

@@ -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_

48
hbase/include/alibabacloud/hbase/model/DescribeRestoreSummaryRequest.h Normal file
View File

@@ -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_

66
hbase/include/alibabacloud/hbase/model/DescribeRestoreSummaryResult.h Normal file
View File

@@ -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_

51
hbase/include/alibabacloud/hbase/model/DescribeRestoreTablesRequest.h Normal file
View File

@@ -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_

51
hbase/include/alibabacloud/hbase/model/DescribeRestoreTablesResult.h Normal file
View File

@@ -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_

57
hbase/include/alibabacloud/hbase/model/EnableHBaseueBackupRequest.h Normal file
View File

@@ -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_

53
hbase/include/alibabacloud/hbase/model/EnableHBaseueBackupResult.h Normal file
View File

@@ -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_

60
hbase/include/alibabacloud/hbase/model/ModifyBackupPlanConfigRequest.h Normal file
View File

@@ -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_

49
hbase/include/alibabacloud/hbase/model/ModifyBackupPlanConfigResult.h Normal file
View File

@@ -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_