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

Support Go SDK.

Browse Source
This commit is contained in:
sdk-team
2019-11-13 10:16:03 +08:00
parent 33986d6ed1
commit f59d8a8426
110 changed files with 9620 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
adb/include/alibabacloud/adb/AdbClient.h Normal file
View File

@@ -0,0 +1,254 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ADB_ADBCLIENT_H_
#define ALIBABACLOUD_ADB_ADBCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "AdbExport.h"
#include "model/AllocateClusterPublicConnectionRequest.h"
#include "model/AllocateClusterPublicConnectionResult.h"
#include "model/CreateAccountRequest.h"
#include "model/CreateAccountResult.h"
#include "model/CreateDBClusterRequest.h"
#include "model/CreateDBClusterResult.h"
#include "model/DeleteAccountRequest.h"
#include "model/DeleteAccountResult.h"
#include "model/DescribeAccountsRequest.h"
#include "model/DescribeAccountsResult.h"
#include "model/DescribeAutoRenewAttributeRequest.h"
#include "model/DescribeAutoRenewAttributeResult.h"
#include "model/DescribeBackupPolicyRequest.h"
#include "model/DescribeBackupPolicyResult.h"
#include "model/DescribeBackupsRequest.h"
#include "model/DescribeBackupsResult.h"
#include "model/DescribeDBClusterAccessWhiteListRequest.h"
#include "model/DescribeDBClusterAccessWhiteListResult.h"
#include "model/DescribeDBClusterAttributeRequest.h"
#include "model/DescribeDBClusterAttributeResult.h"
#include "model/DescribeDBClusterNetInfoRequest.h"
#include "model/DescribeDBClusterNetInfoResult.h"
#include "model/DescribeDBClusterPerformanceRequest.h"
#include "model/DescribeDBClusterPerformanceResult.h"
#include "model/DescribeDBClustersRequest.h"
#include "model/DescribeDBClustersResult.h"
#include "model/DescribeOperatorPermissionRequest.h"
#include "model/DescribeOperatorPermissionResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeSlowLogRecordsRequest.h"
#include "model/DescribeSlowLogRecordsResult.h"
#include "model/DescribeSlowLogTrendRequest.h"
#include "model/DescribeSlowLogTrendResult.h"
#include "model/GrantOperatorPermissionRequest.h"
#include "model/GrantOperatorPermissionResult.h"
#include "model/ModifyAccountDescriptionRequest.h"
#include "model/ModifyAccountDescriptionResult.h"
#include "model/ModifyAutoRenewAttributeRequest.h"
#include "model/ModifyAutoRenewAttributeResult.h"
#include "model/ModifyDBClusterAccessWhiteListRequest.h"
#include "model/ModifyDBClusterAccessWhiteListResult.h"
#include "model/ModifyDBClusterDescriptionRequest.h"
#include "model/ModifyDBClusterDescriptionResult.h"
#include "model/ModifyDBClusterMaintainTimeRequest.h"
#include "model/ModifyDBClusterMaintainTimeResult.h"
#include "model/ReleaseClusterPublicConnectionRequest.h"
#include "model/ReleaseClusterPublicConnectionResult.h"
#include "model/ResetAccountPasswordRequest.h"
#include "model/ResetAccountPasswordResult.h"
#include "model/RevokeOperatorPermissionRequest.h"
#include "model/RevokeOperatorPermissionResult.h"
namespace AlibabaCloud
{
namespace Adb
{
class ALIBABACLOUD_ADB_EXPORT AdbClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AllocateClusterPublicConnectionResult> AllocateClusterPublicConnectionOutcome;
typedef std::future<AllocateClusterPublicConnectionOutcome> AllocateClusterPublicConnectionOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::AllocateClusterPublicConnectionRequest&, const AllocateClusterPublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateClusterPublicConnectionAsyncHandler;
typedef Outcome<Error, Model::CreateAccountResult> CreateAccountOutcome;
typedef std::future<CreateAccountOutcome> CreateAccountOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::CreateAccountRequest&, const CreateAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAccountAsyncHandler;
typedef Outcome<Error, Model::CreateDBClusterResult> CreateDBClusterOutcome;
typedef std::future<CreateDBClusterOutcome> CreateDBClusterOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::CreateDBClusterRequest&, const CreateDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBClusterAsyncHandler;
typedef Outcome<Error, Model::DeleteAccountResult> DeleteAccountOutcome;
typedef std::future<DeleteAccountOutcome> DeleteAccountOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DeleteAccountRequest&, const DeleteAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAccountAsyncHandler;
typedef Outcome<Error, Model::DescribeAccountsResult> DescribeAccountsOutcome;
typedef std::future<DescribeAccountsOutcome> DescribeAccountsOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeAccountsRequest&, const DescribeAccountsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountsAsyncHandler;
typedef Outcome<Error, Model::DescribeAutoRenewAttributeResult> DescribeAutoRenewAttributeOutcome;
typedef std::future<DescribeAutoRenewAttributeOutcome> DescribeAutoRenewAttributeOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeAutoRenewAttributeRequest&, const DescribeAutoRenewAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAutoRenewAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupPolicyResult> DescribeBackupPolicyOutcome;
typedef std::future<DescribeBackupPolicyOutcome> DescribeBackupPolicyOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeBackupPolicyRequest&, const DescribeBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupPolicyAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupsResult> DescribeBackupsOutcome;
typedef std::future<DescribeBackupsOutcome> DescribeBackupsOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeBackupsRequest&, const DescribeBackupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupsAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterAccessWhiteListResult> DescribeDBClusterAccessWhiteListOutcome;
typedef std::future<DescribeDBClusterAccessWhiteListOutcome> DescribeDBClusterAccessWhiteListOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeDBClusterAccessWhiteListRequest&, const DescribeDBClusterAccessWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterAccessWhiteListAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterAttributeResult> DescribeDBClusterAttributeOutcome;
typedef std::future<DescribeDBClusterAttributeOutcome> DescribeDBClusterAttributeOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeDBClusterAttributeRequest&, const DescribeDBClusterAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterNetInfoResult> DescribeDBClusterNetInfoOutcome;
typedef std::future<DescribeDBClusterNetInfoOutcome> DescribeDBClusterNetInfoOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeDBClusterNetInfoRequest&, const DescribeDBClusterNetInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterNetInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterPerformanceResult> DescribeDBClusterPerformanceOutcome;
typedef std::future<DescribeDBClusterPerformanceOutcome> DescribeDBClusterPerformanceOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeDBClusterPerformanceRequest&, const DescribeDBClusterPerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterPerformanceAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClustersResult> DescribeDBClustersOutcome;
typedef std::future<DescribeDBClustersOutcome> DescribeDBClustersOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeDBClustersRequest&, const DescribeDBClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClustersAsyncHandler;
typedef Outcome<Error, Model::DescribeOperatorPermissionResult> DescribeOperatorPermissionOutcome;
typedef std::future<DescribeOperatorPermissionOutcome> DescribeOperatorPermissionOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeOperatorPermissionRequest&, const DescribeOperatorPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOperatorPermissionAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeSlowLogRecordsResult> DescribeSlowLogRecordsOutcome;
typedef std::future<DescribeSlowLogRecordsOutcome> DescribeSlowLogRecordsOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeSlowLogRecordsRequest&, const DescribeSlowLogRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlowLogRecordsAsyncHandler;
typedef Outcome<Error, Model::DescribeSlowLogTrendResult> DescribeSlowLogTrendOutcome;
typedef std::future<DescribeSlowLogTrendOutcome> DescribeSlowLogTrendOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::DescribeSlowLogTrendRequest&, const DescribeSlowLogTrendOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlowLogTrendAsyncHandler;
typedef Outcome<Error, Model::GrantOperatorPermissionResult> GrantOperatorPermissionOutcome;
typedef std::future<GrantOperatorPermissionOutcome> GrantOperatorPermissionOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::GrantOperatorPermissionRequest&, const GrantOperatorPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrantOperatorPermissionAsyncHandler;
typedef Outcome<Error, Model::ModifyAccountDescriptionResult> ModifyAccountDescriptionOutcome;
typedef std::future<ModifyAccountDescriptionOutcome> ModifyAccountDescriptionOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::ModifyAccountDescriptionRequest&, const ModifyAccountDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountDescriptionAsyncHandler;
typedef Outcome<Error, Model::ModifyAutoRenewAttributeResult> ModifyAutoRenewAttributeOutcome;
typedef std::future<ModifyAutoRenewAttributeOutcome> ModifyAutoRenewAttributeOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::ModifyAutoRenewAttributeRequest&, const ModifyAutoRenewAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAutoRenewAttributeAsyncHandler;
typedef Outcome<Error, Model::ModifyDBClusterAccessWhiteListResult> ModifyDBClusterAccessWhiteListOutcome;
typedef std::future<ModifyDBClusterAccessWhiteListOutcome> ModifyDBClusterAccessWhiteListOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::ModifyDBClusterAccessWhiteListRequest&, const ModifyDBClusterAccessWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterAccessWhiteListAsyncHandler;
typedef Outcome<Error, Model::ModifyDBClusterDescriptionResult> ModifyDBClusterDescriptionOutcome;
typedef std::future<ModifyDBClusterDescriptionOutcome> ModifyDBClusterDescriptionOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::ModifyDBClusterDescriptionRequest&, const ModifyDBClusterDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterDescriptionAsyncHandler;
typedef Outcome<Error, Model::ModifyDBClusterMaintainTimeResult> ModifyDBClusterMaintainTimeOutcome;
typedef std::future<ModifyDBClusterMaintainTimeOutcome> ModifyDBClusterMaintainTimeOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::ModifyDBClusterMaintainTimeRequest&, const ModifyDBClusterMaintainTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBClusterMaintainTimeAsyncHandler;
typedef Outcome<Error, Model::ReleaseClusterPublicConnectionResult> ReleaseClusterPublicConnectionOutcome;
typedef std::future<ReleaseClusterPublicConnectionOutcome> ReleaseClusterPublicConnectionOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::ReleaseClusterPublicConnectionRequest&, const ReleaseClusterPublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseClusterPublicConnectionAsyncHandler;
typedef Outcome<Error, Model::ResetAccountPasswordResult> ResetAccountPasswordOutcome;
typedef std::future<ResetAccountPasswordOutcome> ResetAccountPasswordOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::ResetAccountPasswordRequest&, const ResetAccountPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetAccountPasswordAsyncHandler;
typedef Outcome<Error, Model::RevokeOperatorPermissionResult> RevokeOperatorPermissionOutcome;
typedef std::future<RevokeOperatorPermissionOutcome> RevokeOperatorPermissionOutcomeCallable;
typedef std::function<void(const AdbClient*, const Model::RevokeOperatorPermissionRequest&, const RevokeOperatorPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RevokeOperatorPermissionAsyncHandler;
AdbClient(const Credentials &credentials, const ClientConfiguration &configuration);
AdbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
AdbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~AdbClient();
AllocateClusterPublicConnectionOutcome allocateClusterPublicConnection(const Model::AllocateClusterPublicConnectionRequest &request)const;
void allocateClusterPublicConnectionAsync(const Model::AllocateClusterPublicConnectionRequest& request, const AllocateClusterPublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AllocateClusterPublicConnectionOutcomeCallable allocateClusterPublicConnectionCallable(const Model::AllocateClusterPublicConnectionRequest& request) const;
CreateAccountOutcome createAccount(const Model::CreateAccountRequest &request)const;
void createAccountAsync(const Model::CreateAccountRequest& request, const CreateAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAccountOutcomeCallable createAccountCallable(const Model::CreateAccountRequest& request) const;
CreateDBClusterOutcome createDBCluster(const Model::CreateDBClusterRequest &request)const;
void createDBClusterAsync(const Model::CreateDBClusterRequest& request, const CreateDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDBClusterOutcomeCallable createDBClusterCallable(const Model::CreateDBClusterRequest& request) const;
DeleteAccountOutcome deleteAccount(const Model::DeleteAccountRequest &request)const;
void deleteAccountAsync(const Model::DeleteAccountRequest& request, const DeleteAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAccountOutcomeCallable deleteAccountCallable(const Model::DeleteAccountRequest& request) const;
DescribeAccountsOutcome describeAccounts(const Model::DescribeAccountsRequest &request)const;
void describeAccountsAsync(const Model::DescribeAccountsRequest& request, const DescribeAccountsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccountsOutcomeCallable describeAccountsCallable(const Model::DescribeAccountsRequest& request) const;
DescribeAutoRenewAttributeOutcome describeAutoRenewAttribute(const Model::DescribeAutoRenewAttributeRequest &request)const;
void describeAutoRenewAttributeAsync(const Model::DescribeAutoRenewAttributeRequest& request, const DescribeAutoRenewAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAutoRenewAttributeOutcomeCallable describeAutoRenewAttributeCallable(const Model::DescribeAutoRenewAttributeRequest& request) const;
DescribeBackupPolicyOutcome describeBackupPolicy(const Model::DescribeBackupPolicyRequest &request)const;
void describeBackupPolicyAsync(const Model::DescribeBackupPolicyRequest& request, const DescribeBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupPolicyOutcomeCallable describeBackupPolicyCallable(const Model::DescribeBackupPolicyRequest& request) const;
DescribeBackupsOutcome describeBackups(const Model::DescribeBackupsRequest &request)const;
void describeBackupsAsync(const Model::DescribeBackupsRequest& request, const DescribeBackupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupsOutcomeCallable describeBackupsCallable(const Model::DescribeBackupsRequest& request) const;
DescribeDBClusterAccessWhiteListOutcome describeDBClusterAccessWhiteList(const Model::DescribeDBClusterAccessWhiteListRequest &request)const;
void describeDBClusterAccessWhiteListAsync(const Model::DescribeDBClusterAccessWhiteListRequest& request, const DescribeDBClusterAccessWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterAccessWhiteListOutcomeCallable describeDBClusterAccessWhiteListCallable(const Model::DescribeDBClusterAccessWhiteListRequest& request) const;
DescribeDBClusterAttributeOutcome describeDBClusterAttribute(const Model::DescribeDBClusterAttributeRequest &request)const;
void describeDBClusterAttributeAsync(const Model::DescribeDBClusterAttributeRequest& request, const DescribeDBClusterAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterAttributeOutcomeCallable describeDBClusterAttributeCallable(const Model::DescribeDBClusterAttributeRequest& request) const;
DescribeDBClusterNetInfoOutcome describeDBClusterNetInfo(const Model::DescribeDBClusterNetInfoRequest &request)const;
void describeDBClusterNetInfoAsync(const Model::DescribeDBClusterNetInfoRequest& request, const DescribeDBClusterNetInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterNetInfoOutcomeCallable describeDBClusterNetInfoCallable(const Model::DescribeDBClusterNetInfoRequest& request) const;
DescribeDBClusterPerformanceOutcome describeDBClusterPerformance(const Model::DescribeDBClusterPerformanceRequest &request)const;
void describeDBClusterPerformanceAsync(const Model::DescribeDBClusterPerformanceRequest& request, const DescribeDBClusterPerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterPerformanceOutcomeCallable describeDBClusterPerformanceCallable(const Model::DescribeDBClusterPerformanceRequest& request) const;
DescribeDBClustersOutcome describeDBClusters(const Model::DescribeDBClustersRequest &request)const;
void describeDBClustersAsync(const Model::DescribeDBClustersRequest& request, const DescribeDBClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClustersOutcomeCallable describeDBClustersCallable(const Model::DescribeDBClustersRequest& request) const;
DescribeOperatorPermissionOutcome describeOperatorPermission(const Model::DescribeOperatorPermissionRequest &request)const;
void describeOperatorPermissionAsync(const Model::DescribeOperatorPermissionRequest& request, const DescribeOperatorPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeOperatorPermissionOutcomeCallable describeOperatorPermissionCallable(const Model::DescribeOperatorPermissionRequest& 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;
DescribeSlowLogRecordsOutcome describeSlowLogRecords(const Model::DescribeSlowLogRecordsRequest &request)const;
void describeSlowLogRecordsAsync(const Model::DescribeSlowLogRecordsRequest& request, const DescribeSlowLogRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSlowLogRecordsOutcomeCallable describeSlowLogRecordsCallable(const Model::DescribeSlowLogRecordsRequest& request) const;
DescribeSlowLogTrendOutcome describeSlowLogTrend(const Model::DescribeSlowLogTrendRequest &request)const;
void describeSlowLogTrendAsync(const Model::DescribeSlowLogTrendRequest& request, const DescribeSlowLogTrendAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSlowLogTrendOutcomeCallable describeSlowLogTrendCallable(const Model::DescribeSlowLogTrendRequest& request) const;
GrantOperatorPermissionOutcome grantOperatorPermission(const Model::GrantOperatorPermissionRequest &request)const;
void grantOperatorPermissionAsync(const Model::GrantOperatorPermissionRequest& request, const GrantOperatorPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GrantOperatorPermissionOutcomeCallable grantOperatorPermissionCallable(const Model::GrantOperatorPermissionRequest& request) const;
ModifyAccountDescriptionOutcome modifyAccountDescription(const Model::ModifyAccountDescriptionRequest &request)const;
void modifyAccountDescriptionAsync(const Model::ModifyAccountDescriptionRequest& request, const ModifyAccountDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyAccountDescriptionOutcomeCallable modifyAccountDescriptionCallable(const Model::ModifyAccountDescriptionRequest& request) const;
ModifyAutoRenewAttributeOutcome modifyAutoRenewAttribute(const Model::ModifyAutoRenewAttributeRequest &request)const;
void modifyAutoRenewAttributeAsync(const Model::ModifyAutoRenewAttributeRequest& request, const ModifyAutoRenewAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyAutoRenewAttributeOutcomeCallable modifyAutoRenewAttributeCallable(const Model::ModifyAutoRenewAttributeRequest& request) const;
ModifyDBClusterAccessWhiteListOutcome modifyDBClusterAccessWhiteList(const Model::ModifyDBClusterAccessWhiteListRequest &request)const;
void modifyDBClusterAccessWhiteListAsync(const Model::ModifyDBClusterAccessWhiteListRequest& request, const ModifyDBClusterAccessWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBClusterAccessWhiteListOutcomeCallable modifyDBClusterAccessWhiteListCallable(const Model::ModifyDBClusterAccessWhiteListRequest& request) const;
ModifyDBClusterDescriptionOutcome modifyDBClusterDescription(const Model::ModifyDBClusterDescriptionRequest &request)const;
void modifyDBClusterDescriptionAsync(const Model::ModifyDBClusterDescriptionRequest& request, const ModifyDBClusterDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBClusterDescriptionOutcomeCallable modifyDBClusterDescriptionCallable(const Model::ModifyDBClusterDescriptionRequest& request) const;
ModifyDBClusterMaintainTimeOutcome modifyDBClusterMaintainTime(const Model::ModifyDBClusterMaintainTimeRequest &request)const;
void modifyDBClusterMaintainTimeAsync(const Model::ModifyDBClusterMaintainTimeRequest& request, const ModifyDBClusterMaintainTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBClusterMaintainTimeOutcomeCallable modifyDBClusterMaintainTimeCallable(const Model::ModifyDBClusterMaintainTimeRequest& request) const;
ReleaseClusterPublicConnectionOutcome releaseClusterPublicConnection(const Model::ReleaseClusterPublicConnectionRequest &request)const;
void releaseClusterPublicConnectionAsync(const Model::ReleaseClusterPublicConnectionRequest& request, const ReleaseClusterPublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReleaseClusterPublicConnectionOutcomeCallable releaseClusterPublicConnectionCallable(const Model::ReleaseClusterPublicConnectionRequest& request) const;
ResetAccountPasswordOutcome resetAccountPassword(const Model::ResetAccountPasswordRequest &request)const;
void resetAccountPasswordAsync(const Model::ResetAccountPasswordRequest& request, const ResetAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ResetAccountPasswordOutcomeCallable resetAccountPasswordCallable(const Model::ResetAccountPasswordRequest& request) const;
RevokeOperatorPermissionOutcome revokeOperatorPermission(const Model::RevokeOperatorPermissionRequest &request)const;
void revokeOperatorPermissionAsync(const Model::RevokeOperatorPermissionRequest& request, const RevokeOperatorPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RevokeOperatorPermissionOutcomeCallable revokeOperatorPermissionCallable(const Model::RevokeOperatorPermissionRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_ADB_ADBCLIENT_H_

32
adb/include/alibabacloud/adb/AdbExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_ADBEXPORT_H_
#define ALIBABACLOUD_ADB_ADBEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_ADB_LIBRARY)
# define ALIBABACLOUD_ADB_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_ADB_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_ADB_EXPORT
#endif
#endif // !ALIBABACLOUD_ADB_ADBEXPORT_H_

66
adb/include/alibabacloud/adb/model/AllocateClusterPublicConnectionRequest.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_ADB_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT AllocateClusterPublicConnectionRequest : public RpcServiceRequest
{
public:
AllocateClusterPublicConnectionRequest();
~AllocateClusterPublicConnectionRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getConnectionStringPrefix()const;
void setConnectionStringPrefix(const std::string& connectionStringPrefix);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string connectionStringPrefix_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONREQUEST_H_

49
adb/include/alibabacloud/adb/model/AllocateClusterPublicConnectionResult.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_ADB_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT AllocateClusterPublicConnectionResult : public ServiceResult
{
public:
AllocateClusterPublicConnectionResult();
explicit AllocateClusterPublicConnectionResult(const std::string &payload);
~AllocateClusterPublicConnectionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_ALLOCATECLUSTERPUBLICCONNECTIONRESULT_H_

72
adb/include/alibabacloud/adb/model/CreateAccountRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_CREATEACCOUNTREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_CREATEACCOUNTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT CreateAccountRequest : public RpcServiceRequest
{
public:
CreateAccountRequest();
~CreateAccountRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccountDescription()const;
void setAccountDescription(const std::string& accountDescription);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccountPassword()const;
void setAccountPassword(const std::string& accountPassword);
private:
long resourceOwnerId_;
std::string accountDescription_;
std::string accessKeyId_;
std::string accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string accountPassword_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_CREATEACCOUNTREQUEST_H_

49
adb/include/alibabacloud/adb/model/CreateAccountResult.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_ADB_MODEL_CREATEACCOUNTRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_CREATEACCOUNTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT CreateAccountResult : public ServiceResult
{
public:
CreateAccountResult();
explicit CreateAccountResult(const std::string &payload);
~CreateAccountResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_CREATEACCOUNTRESULT_H_

105
adb/include/alibabacloud/adb/model/CreateDBClusterRequest.h Normal file
View File

@@ -0,0 +1,105 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ADB_MODEL_CREATEDBCLUSTERREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_CREATEDBCLUSTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT CreateDBClusterRequest : public RpcServiceRequest
{
public:
CreateDBClusterRequest();
~CreateDBClusterRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDBClusterDescription()const;
void setDBClusterDescription(const std::string& dBClusterDescription);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDBClusterCategory()const;
void setDBClusterCategory(const std::string& dBClusterCategory);
std::string getDBClusterNetworkType()const;
void setDBClusterNetworkType(const std::string& dBClusterNetworkType);
std::string getPeriod()const;
void setPeriod(const std::string& period);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getDBClusterVersion()const;
void setDBClusterVersion(const std::string& dBClusterVersion);
std::string getDBClusterClass()const;
void setDBClusterClass(const std::string& dBClusterClass);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDBNodeGroupCount()const;
void setDBNodeGroupCount(const std::string& dBNodeGroupCount);
std::string getUsedTime()const;
void setUsedTime(const std::string& usedTime);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getDBNodeStorage()const;
void setDBNodeStorage(const std::string& dBNodeStorage);
std::string getVPCId()const;
void setVPCId(const std::string& vPCId);
std::string getZoneId()const;
void setZoneId(const std::string& zoneId);
std::string getPayType()const;
void setPayType(const std::string& payType);
private:
long resourceOwnerId_;
std::string dBClusterDescription_;
std::string clientToken_;
std::string accessKeyId_;
std::string regionId_;
std::string dBClusterCategory_;
std::string dBClusterNetworkType_;
std::string period_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string dBClusterVersion_;
std::string dBClusterClass_;
long ownerId_;
std::string dBNodeGroupCount_;
std::string usedTime_;
std::string vSwitchId_;
std::string dBNodeStorage_;
std::string vPCId_;
std::string zoneId_;
std::string payType_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_CREATEDBCLUSTERREQUEST_H_

53
adb/include/alibabacloud/adb/model/CreateDBClusterResult.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_ADB_MODEL_CREATEDBCLUSTERRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_CREATEDBCLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT CreateDBClusterResult : public ServiceResult
{
public:
CreateDBClusterResult();
explicit CreateDBClusterResult(const std::string &payload);
~CreateDBClusterResult();
std::string getDBClusterId()const;
std::string getOrderId()const;
protected:
void parse(const std::string &payload);
private:
std::string dBClusterId_;
std::string orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_CREATEDBCLUSTERRESULT_H_

66
adb/include/alibabacloud/adb/model/DeleteAccountRequest.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_ADB_MODEL_DELETEACCOUNTREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DELETEACCOUNTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DeleteAccountRequest : public RpcServiceRequest
{
public:
DeleteAccountRequest();
~DeleteAccountRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DELETEACCOUNTREQUEST_H_

49
adb/include/alibabacloud/adb/model/DeleteAccountResult.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_ADB_MODEL_DELETEACCOUNTRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DELETEACCOUNTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DeleteAccountResult : public ServiceResult
{
public:
DeleteAccountResult();
explicit DeleteAccountResult(const std::string &payload);
~DeleteAccountResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DELETEACCOUNTRESULT_H_

66
adb/include/alibabacloud/adb/model/DescribeAccountsRequest.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_ADB_MODEL_DESCRIBEACCOUNTSREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEACCOUNTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeAccountsRequest : public RpcServiceRequest
{
public:
DescribeAccountsRequest();
~DescribeAccountsRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEACCOUNTSREQUEST_H_

58
adb/include/alibabacloud/adb/model/DescribeAccountsResult.h Normal file
View File

@@ -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.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_DESCRIBEACCOUNTSRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEACCOUNTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeAccountsResult : public ServiceResult
{
public:
struct DBAccount
{
std::string accountDescription;
std::string accountStatus;
std::string accountType;
std::string accountName;
};
DescribeAccountsResult();
explicit DescribeAccountsResult(const std::string &payload);
~DescribeAccountsResult();
std::vector<DBAccount> getAccountList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DBAccount> accountList_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEACCOUNTSRESULT_H_

72
adb/include/alibabacloud/adb/model/DescribeAutoRenewAttributeRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_DESCRIBEAUTORENEWATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEAUTORENEWATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeAutoRenewAttributeRequest : public RpcServiceRequest
{
public:
DescribeAutoRenewAttributeRequest();
~DescribeAutoRenewAttributeRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDBClusterIds()const;
void setDBClusterIds(const std::string& dBClusterIds);
private:
long resourceOwnerId_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string dBClusterIds_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEAUTORENEWATTRIBUTEREQUEST_H_

66
adb/include/alibabacloud/adb/model/DescribeAutoRenewAttributeResult.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_ADB_MODEL_DESCRIBEAUTORENEWATTRIBUTERESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEAUTORENEWATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeAutoRenewAttributeResult : public ServiceResult
{
public:
struct AutoRenewAttribute
{
bool autoRenewEnabled;
std::string dBClusterId;
std::string renewalStatus;
int duration;
std::string regionId;
std::string periodUnit;
};
DescribeAutoRenewAttributeResult();
explicit DescribeAutoRenewAttributeResult(const std::string &payload);
~DescribeAutoRenewAttributeResult();
int getTotalRecordCount()const;
int getPageRecordCount()const;
int getPageNumber()const;
std::vector<AutoRenewAttribute> getItems()const;
protected:
void parse(const std::string &payload);
private:
int totalRecordCount_;
int pageRecordCount_;
int pageNumber_;
std::vector<AutoRenewAttribute> items_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEAUTORENEWATTRIBUTERESULT_H_

63
adb/include/alibabacloud/adb/model/DescribeBackupPolicyRequest.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_ADB_MODEL_DESCRIBEBACKUPPOLICYREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEBACKUPPOLICYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeBackupPolicyRequest : public RpcServiceRequest
{
public:
DescribeBackupPolicyRequest();
~DescribeBackupPolicyRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEBACKUPPOLICYREQUEST_H_

59
adb/include/alibabacloud/adb/model/DescribeBackupPolicyResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeBackupPolicyResult : public ServiceResult
{
public:
DescribeBackupPolicyResult();
explicit DescribeBackupPolicyResult(const std::string &payload);
~DescribeBackupPolicyResult();
std::string getPreferredBackupPeriod()const;
int getLogBackupRetentionPeriod()const;
std::string getPreferredBackupTime()const;
std::string getEnableBackupLog()const;
int getBackupRetentionPeriod()const;
protected:
void parse(const std::string &payload);
private:
std::string preferredBackupPeriod_;
int logBackupRetentionPeriod_;
std::string preferredBackupTime_;
std::string enableBackupLog_;
int backupRetentionPeriod_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_

78
adb/include/alibabacloud/adb/model/DescribeBackupsRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ADB_MODEL_DESCRIBEBACKUPSREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEBACKUPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeBackupsRequest : public RpcServiceRequest
{
public:
DescribeBackupsRequest();
~DescribeBackupsRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getBackupId()const;
void setBackupId(const std::string& backupId);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string startTime_;
int pageNumber_;
std::string accessKeyId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string backupId_;
std::string endTime_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEBACKUPSREQUEST_H_

67
adb/include/alibabacloud/adb/model/DescribeBackupsResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ADB_MODEL_DESCRIBEBACKUPSRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEBACKUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeBackupsResult : public ServiceResult
{
public:
struct Backup
{
std::string backupMethod;
std::string backupEndTime;
int backupSize;
std::string dBClusterId;
std::string backupStartTime;
std::string backupId;
std::string backupType;
};
DescribeBackupsResult();
explicit DescribeBackupsResult(const std::string &payload);
~DescribeBackupsResult();
std::string getTotalCount()const;
std::string getPageSize()const;
std::string getPageNumber()const;
std::vector<Backup> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::string totalCount_;
std::string pageSize_;
std::string pageNumber_;
std::vector<Backup> items_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEBACKUPSRESULT_H_

63
adb/include/alibabacloud/adb/model/DescribeDBClusterAccessWhiteListRequest.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_ADB_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClusterAccessWhiteListRequest : public RpcServiceRequest
{
public:
DescribeDBClusterAccessWhiteListRequest();
~DescribeDBClusterAccessWhiteListRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTREQUEST_H_

57
adb/include/alibabacloud/adb/model/DescribeDBClusterAccessWhiteListResult.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_ADB_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClusterAccessWhiteListResult : public ServiceResult
{
public:
struct IPArray
{
std::string dBClusterIPArrayName;
std::string securityIPList;
std::string dBClusterIPArrayAttribute;
};
DescribeDBClusterAccessWhiteListResult();
explicit DescribeDBClusterAccessWhiteListResult(const std::string &payload);
~DescribeDBClusterAccessWhiteListResult();
std::vector<IPArray> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::vector<IPArray> items_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERACCESSWHITELISTRESULT_H_

63
adb/include/alibabacloud/adb/model/DescribeDBClusterAttributeRequest.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_ADB_MODEL_DESCRIBEDBCLUSTERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClusterAttributeRequest : public RpcServiceRequest
{
public:
DescribeDBClusterAttributeRequest();
~DescribeDBClusterAttributeRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERATTRIBUTEREQUEST_H_

84
adb/include/alibabacloud/adb/model/DescribeDBClusterAttributeResult.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERATTRIBUTERESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClusterAttributeResult : public ServiceResult
{
public:
struct DBCluster
{
struct Tag
{
std::string value;
std::string key;
};
std::string category;
std::string dBClusterId;
std::string dBClusterNetworkType;
std::string dBClusterType;
std::string dBVersion;
long dBNodeCount;
std::string commodityCode;
std::string lockReason;
std::string maintainTime;
std::vector<DBCluster::Tag> tags;
std::string engine;
long dBNodeStorage;
std::string zoneId;
std::string vPCId;
std::string dBClusterStatus;
std::string vSwitchId;
std::string dBClusterDescription;
std::string expired;
std::string lockMode;
std::string payType;
std::string dBNodeClass;
std::string vPCCloudInstanceId;
std::string creationTime;
std::string regionId;
std::string expireTime;
};
DescribeDBClusterAttributeResult();
explicit DescribeDBClusterAttributeResult(const std::string &payload);
~DescribeDBClusterAttributeResult();
std::vector<DBCluster> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DBCluster> items_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERATTRIBUTERESULT_H_

63
adb/include/alibabacloud/adb/model/DescribeDBClusterNetInfoRequest.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_ADB_MODEL_DESCRIBEDBCLUSTERNETINFOREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERNETINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClusterNetInfoRequest : public RpcServiceRequest
{
public:
DescribeDBClusterNetInfoRequest();
~DescribeDBClusterNetInfoRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERNETINFOREQUEST_H_

62
adb/include/alibabacloud/adb/model/DescribeDBClusterNetInfoResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERNETINFORESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERNETINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClusterNetInfoResult : public ServiceResult
{
public:
struct Address
{
std::string vPCId;
std::string port;
std::string vSwitchId;
std::string connectionString;
std::string iPAddress;
std::string netType;
};
DescribeDBClusterNetInfoResult();
explicit DescribeDBClusterNetInfoResult(const std::string &payload);
~DescribeDBClusterNetInfoResult();
std::string getClusterNetworkType()const;
std::vector<Address> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::string clusterNetworkType_;
std::vector<Address> items_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERNETINFORESULT_H_

72
adb/include/alibabacloud/adb/model/DescribeDBClusterPerformanceRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERPERFORMANCEREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERPERFORMANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClusterPerformanceRequest : public RpcServiceRequest
{
public:
DescribeDBClusterPerformanceRequest();
~DescribeDBClusterPerformanceRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getKey()const;
void setKey(const std::string& key);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string startTime_;
std::string accessKeyId_;
std::string key_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string endTime_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERPERFORMANCEREQUEST_H_

68
adb/include/alibabacloud/adb/model/DescribeDBClusterPerformanceResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ADB_MODEL_DESCRIBEDBCLUSTERPERFORMANCERESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERPERFORMANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClusterPerformanceResult : public ServiceResult
{
public:
struct PerformanceItem
{
struct SeriesItem
{
std::vector<std::string> values;
std::string name;
};
std::vector<PerformanceItem::SeriesItem> series;
std::string unit;
std::string key;
};
DescribeDBClusterPerformanceResult();
explicit DescribeDBClusterPerformanceResult(const std::string &payload);
~DescribeDBClusterPerformanceResult();
std::string getEndTime()const;
std::string getDBClusterId()const;
std::string getStartTime()const;
std::vector<PerformanceItem> getPerformances()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::string dBClusterId_;
std::string startTime_;
std::vector<PerformanceItem> performances_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERPERFORMANCERESULT_H_

86
adb/include/alibabacloud/adb/model/DescribeDBClustersRequest.h Normal file
View File

@@ -0,0 +1,86 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ADB_MODEL_DESCRIBEDBCLUSTERSREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClustersRequest : public RpcServiceRequest
{
struct Tag
{
std::string value;
std::string key;
};
public:
DescribeDBClustersRequest();
~DescribeDBClustersRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDBClusterDescription()const;
void setDBClusterDescription(const std::string& dBClusterDescription);
std::string getDBClusterStatus()const;
void setDBClusterStatus(const std::string& dBClusterStatus);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
std::vector<Tag> getTag()const;
void setTag(const std::vector<Tag>& tag);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDBClusterIds()const;
void setDBClusterIds(const std::string& dBClusterIds);
private:
long resourceOwnerId_;
std::string dBClusterDescription_;
std::string dBClusterStatus_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string dBClusterIds_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERSREQUEST_H_

82
adb/include/alibabacloud/adb/model/DescribeDBClustersResult.h Normal file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ADB_MODEL_DESCRIBEDBCLUSTERSRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeDBClustersResult : public ServiceResult
{
public:
struct DBCluster
{
struct Tag
{
std::string value;
std::string key;
};
long dBNodeStorage;
std::string dBClusterStatus;
std::string createTime;
std::string dBClusterId;
std::string dBClusterDescription;
std::string expired;
std::string payType;
std::string lockMode;
std::string dBNodeClass;
std::string dBClusterType;
std::string dBVersion;
long dBNodeCount;
std::string commodityCode;
std::string regionId;
std::string expireTime;
std::string lockReason;
std::vector<DBCluster::Tag> tags;
};
DescribeDBClustersResult();
explicit DescribeDBClustersResult(const std::string &payload);
~DescribeDBClustersResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<DBCluster> getItems()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<DBCluster> items_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEDBCLUSTERSRESULT_H_

63
adb/include/alibabacloud/adb/model/DescribeOperatorPermissionRequest.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_ADB_MODEL_DESCRIBEOPERATORPERMISSIONREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEOPERATORPERMISSIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeOperatorPermissionRequest : public RpcServiceRequest
{
public:
DescribeOperatorPermissionRequest();
~DescribeOperatorPermissionRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEOPERATORPERMISSIONREQUEST_H_

57
adb/include/alibabacloud/adb/model/DescribeOperatorPermissionResult.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_ADB_MODEL_DESCRIBEOPERATORPERMISSIONRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEOPERATORPERMISSIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeOperatorPermissionResult : public ServiceResult
{
public:
DescribeOperatorPermissionResult();
explicit DescribeOperatorPermissionResult(const std::string &payload);
~DescribeOperatorPermissionResult();
std::string getCreatedTime()const;
std::string getPrivileges()const;
std::string getExpiredTime()const;
std::string getDBClusterId()const;
protected:
void parse(const std::string &payload);
private:
std::string createdTime_;
std::string privileges_;
std::string expiredTime_;
std::string dBClusterId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEOPERATORPERMISSIONRESULT_H_

60
adb/include/alibabacloud/adb/model/DescribeRegionsRequest.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_ADB_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBEREGIONSREQUEST_H_

61
adb/include/alibabacloud/adb/model/DescribeRegionsResult.h Normal file
View File

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

78
adb/include/alibabacloud/adb/model/DescribeSlowLogRecordsRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ADB_MODEL_DESCRIBESLOWLOGRECORDSREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGRECORDSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeSlowLogRecordsRequest : public RpcServiceRequest
{
public:
DescribeSlowLogRecordsRequest();
~DescribeSlowLogRecordsRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDBName()const;
void setDBName(const std::string& dBName);
private:
long resourceOwnerId_;
std::string startTime_;
int pageNumber_;
std::string accessKeyId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string endTime_;
long ownerId_;
std::string dBName_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGRECORDSREQUEST_H_

71
adb/include/alibabacloud/adb/model/DescribeSlowLogRecordsResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGRECORDSRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGRECORDSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeSlowLogRecordsResult : public ServiceResult
{
public:
struct SlowLogRecord
{
std::string userName;
std::string executionStartTime;
long returnRowCounts;
std::string dBName;
long queryTime;
long parseRowCounts;
std::string processID;
std::string hostAddress;
std::string sQLText;
};
DescribeSlowLogRecordsResult();
explicit DescribeSlowLogRecordsResult(const std::string &payload);
~DescribeSlowLogRecordsResult();
std::string getTotalCount()const;
std::string getPageSize()const;
std::string getPageNumber()const;
std::string getDBClusterId()const;
std::vector<SlowLogRecord> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::string totalCount_;
std::string pageSize_;
std::string pageNumber_;
std::string dBClusterId_;
std::vector<SlowLogRecord> items_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGRECORDSRESULT_H_

72
adb/include/alibabacloud/adb/model/DescribeSlowLogTrendRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGTRENDREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGTRENDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeSlowLogTrendRequest : public RpcServiceRequest
{
public:
DescribeSlowLogTrendRequest();
~DescribeSlowLogTrendRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDBName()const;
void setDBName(const std::string& dBName);
private:
long resourceOwnerId_;
std::string startTime_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string endTime_;
long ownerId_;
std::string dBName_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGTRENDREQUEST_H_

68
adb/include/alibabacloud/adb/model/DescribeSlowLogTrendResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ADB_MODEL_DESCRIBESLOWLOGTRENDRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGTRENDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT DescribeSlowLogTrendResult : public ServiceResult
{
public:
struct SlowLogTrendItem
{
struct SeriesItem
{
std::string values;
std::string name;
};
std::vector<SlowLogTrendItem::SeriesItem> series;
std::string unit;
std::string key;
};
DescribeSlowLogTrendResult();
explicit DescribeSlowLogTrendResult(const std::string &payload);
~DescribeSlowLogTrendResult();
std::string getEndTime()const;
std::string getDBClusterId()const;
std::string getStartTime()const;
std::vector<SlowLogTrendItem> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::string endTime_;
std::string dBClusterId_;
std::string startTime_;
std::vector<SlowLogTrendItem> items_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_DESCRIBESLOWLOGTRENDRESULT_H_

69
adb/include/alibabacloud/adb/model/GrantOperatorPermissionRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_GRANTOPERATORPERMISSIONREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_GRANTOPERATORPERMISSIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT GrantOperatorPermissionRequest : public RpcServiceRequest
{
public:
GrantOperatorPermissionRequest();
~GrantOperatorPermissionRequest();
std::string getPrivileges()const;
void setPrivileges(const std::string& privileges);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getExpiredTime()const;
void setExpiredTime(const std::string& expiredTime);
private:
std::string privileges_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string expiredTime_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_GRANTOPERATORPERMISSIONREQUEST_H_

49
adb/include/alibabacloud/adb/model/GrantOperatorPermissionResult.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_ADB_MODEL_GRANTOPERATORPERMISSIONRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_GRANTOPERATORPERMISSIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT GrantOperatorPermissionResult : public ServiceResult
{
public:
GrantOperatorPermissionResult();
explicit GrantOperatorPermissionResult(const std::string &payload);
~GrantOperatorPermissionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_GRANTOPERATORPERMISSIONRESULT_H_

69
adb/include/alibabacloud/adb/model/ModifyAccountDescriptionRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyAccountDescriptionRequest : public RpcServiceRequest
{
public:
ModifyAccountDescriptionRequest();
~ModifyAccountDescriptionRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccountDescription()const;
void setAccountDescription(const std::string& accountDescription);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accountDescription_;
std::string accessKeyId_;
std::string accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_

49
adb/include/alibabacloud/adb/model/ModifyAccountDescriptionResult.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_ADB_MODEL_MODIFYACCOUNTDESCRIPTIONRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYACCOUNTDESCRIPTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyAccountDescriptionResult : public ServiceResult
{
public:
ModifyAccountDescriptionResult();
explicit ModifyAccountDescriptionResult(const std::string &payload);
~ModifyAccountDescriptionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYACCOUNTDESCRIPTIONRESULT_H_

75
adb/include/alibabacloud/adb/model/ModifyAutoRenewAttributeRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_MODIFYAUTORENEWATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYAUTORENEWATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyAutoRenewAttributeRequest : public RpcServiceRequest
{
public:
ModifyAutoRenewAttributeRequest();
~ModifyAutoRenewAttributeRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getDuration()const;
void setDuration(const std::string& duration);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getRenewalStatus()const;
void setRenewalStatus(const std::string& renewalStatus);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getPeriodUnit()const;
void setPeriodUnit(const std::string& periodUnit);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string duration_;
std::string regionId_;
std::string renewalStatus_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string periodUnit_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYAUTORENEWATTRIBUTEREQUEST_H_

49
adb/include/alibabacloud/adb/model/ModifyAutoRenewAttributeResult.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_ADB_MODEL_MODIFYAUTORENEWATTRIBUTERESULT_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYAUTORENEWATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyAutoRenewAttributeResult : public ServiceResult
{
public:
ModifyAutoRenewAttributeResult();
explicit ModifyAutoRenewAttributeResult(const std::string &payload);
~ModifyAutoRenewAttributeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYAUTORENEWATTRIBUTERESULT_H_

75
adb/include/alibabacloud/adb/model/ModifyDBClusterAccessWhiteListRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERACCESSWHITELISTREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERACCESSWHITELISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyDBClusterAccessWhiteListRequest : public RpcServiceRequest
{
public:
ModifyDBClusterAccessWhiteListRequest();
~ModifyDBClusterAccessWhiteListRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getSecurityIps()const;
void setSecurityIps(const std::string& securityIps);
std::string getDBClusterIPArrayAttribute()const;
void setDBClusterIPArrayAttribute(const std::string& dBClusterIPArrayAttribute);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getModifyMode()const;
void setModifyMode(const std::string& modifyMode);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDBClusterIPArrayName()const;
void setDBClusterIPArrayName(const std::string& dBClusterIPArrayName);
private:
long resourceOwnerId_;
std::string securityIps_;
std::string dBClusterIPArrayAttribute_;
std::string accessKeyId_;
std::string modifyMode_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string dBClusterIPArrayName_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERACCESSWHITELISTREQUEST_H_

49
adb/include/alibabacloud/adb/model/ModifyDBClusterAccessWhiteListResult.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_ADB_MODEL_MODIFYDBCLUSTERACCESSWHITELISTRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERACCESSWHITELISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyDBClusterAccessWhiteListResult : public ServiceResult
{
public:
ModifyDBClusterAccessWhiteListResult();
explicit ModifyDBClusterAccessWhiteListResult(const std::string &payload);
~ModifyDBClusterAccessWhiteListResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERACCESSWHITELISTRESULT_H_

66
adb/include/alibabacloud/adb/model/ModifyDBClusterDescriptionRequest.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_ADB_MODEL_MODIFYDBCLUSTERDESCRIPTIONREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERDESCRIPTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyDBClusterDescriptionRequest : public RpcServiceRequest
{
public:
ModifyDBClusterDescriptionRequest();
~ModifyDBClusterDescriptionRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDBClusterDescription()const;
void setDBClusterDescription(const std::string& dBClusterDescription);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string dBClusterDescription_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERDESCRIPTIONREQUEST_H_

49
adb/include/alibabacloud/adb/model/ModifyDBClusterDescriptionResult.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_ADB_MODEL_MODIFYDBCLUSTERDESCRIPTIONRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERDESCRIPTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyDBClusterDescriptionResult : public ServiceResult
{
public:
ModifyDBClusterDescriptionResult();
explicit ModifyDBClusterDescriptionResult(const std::string &payload);
~ModifyDBClusterDescriptionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERDESCRIPTIONRESULT_H_

66
adb/include/alibabacloud/adb/model/ModifyDBClusterMaintainTimeRequest.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_ADB_MODEL_MODIFYDBCLUSTERMAINTAINTIMEREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERMAINTAINTIMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyDBClusterMaintainTimeRequest : public RpcServiceRequest
{
public:
ModifyDBClusterMaintainTimeRequest();
~ModifyDBClusterMaintainTimeRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getMaintainTime()const;
void setMaintainTime(const std::string& maintainTime);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string maintainTime_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERMAINTAINTIMEREQUEST_H_

49
adb/include/alibabacloud/adb/model/ModifyDBClusterMaintainTimeResult.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_ADB_MODEL_MODIFYDBCLUSTERMAINTAINTIMERESULT_H_
#define ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERMAINTAINTIMERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ModifyDBClusterMaintainTimeResult : public ServiceResult
{
public:
ModifyDBClusterMaintainTimeResult();
explicit ModifyDBClusterMaintainTimeResult(const std::string &payload);
~ModifyDBClusterMaintainTimeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_MODIFYDBCLUSTERMAINTAINTIMERESULT_H_

63
adb/include/alibabacloud/adb/model/ReleaseClusterPublicConnectionRequest.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_ADB_MODEL_RELEASECLUSTERPUBLICCONNECTIONREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_RELEASECLUSTERPUBLICCONNECTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ReleaseClusterPublicConnectionRequest : public RpcServiceRequest
{
public:
ReleaseClusterPublicConnectionRequest();
~ReleaseClusterPublicConnectionRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_RELEASECLUSTERPUBLICCONNECTIONREQUEST_H_

49
adb/include/alibabacloud/adb/model/ReleaseClusterPublicConnectionResult.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_ADB_MODEL_RELEASECLUSTERPUBLICCONNECTIONRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_RELEASECLUSTERPUBLICCONNECTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ReleaseClusterPublicConnectionResult : public ServiceResult
{
public:
ReleaseClusterPublicConnectionResult();
explicit ReleaseClusterPublicConnectionResult(const std::string &payload);
~ReleaseClusterPublicConnectionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_RELEASECLUSTERPUBLICCONNECTIONRESULT_H_

69
adb/include/alibabacloud/adb/model/ResetAccountPasswordRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADB_MODEL_RESETACCOUNTPASSWORDREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_RESETACCOUNTPASSWORDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ResetAccountPasswordRequest : public RpcServiceRequest
{
public:
ResetAccountPasswordRequest();
~ResetAccountPasswordRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccountPassword()const;
void setAccountPassword(const std::string& accountPassword);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string accountPassword_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_RESETACCOUNTPASSWORDREQUEST_H_

49
adb/include/alibabacloud/adb/model/ResetAccountPasswordResult.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_ADB_MODEL_RESETACCOUNTPASSWORDRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_RESETACCOUNTPASSWORDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT ResetAccountPasswordResult : public ServiceResult
{
public:
ResetAccountPasswordResult();
explicit ResetAccountPasswordResult(const std::string &payload);
~ResetAccountPasswordResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_RESETACCOUNTPASSWORDRESULT_H_

63
adb/include/alibabacloud/adb/model/RevokeOperatorPermissionRequest.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_ADB_MODEL_REVOKEOPERATORPERMISSIONREQUEST_H_
#define ALIBABACLOUD_ADB_MODEL_REVOKEOPERATORPERMISSIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT RevokeOperatorPermissionRequest : public RpcServiceRequest
{
public:
RevokeOperatorPermissionRequest();
~RevokeOperatorPermissionRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_REVOKEOPERATORPERMISSIONREQUEST_H_

49
adb/include/alibabacloud/adb/model/RevokeOperatorPermissionResult.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_ADB_MODEL_REVOKEOPERATORPERMISSIONRESULT_H_
#define ALIBABACLOUD_ADB_MODEL_REVOKEOPERATORPERMISSIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adb/AdbExport.h>
namespace AlibabaCloud
{
namespace Adb
{
namespace Model
{
class ALIBABACLOUD_ADB_EXPORT RevokeOperatorPermissionResult : public ServiceResult
{
public:
RevokeOperatorPermissionResult();
explicit RevokeOperatorPermissionResult(const std::string &payload);
~RevokeOperatorPermissionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADB_MODEL_REVOKEOPERATORPERMISSIONRESULT_H_