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

Cloud Storage Gateway openapi sdk is released.

Browse Source
This commit is contained in:
sdk-team
2020-10-21 08:58:16 +00:00
parent 1309d87fdb
commit 0cf373bc60
465 changed files with 39395 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

966
sgw/include/alibabacloud/sgw/SgwClient.h Normal file
View File

@@ -0,0 +1,966 @@
/*
* 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_SGW_SGWCLIENT_H_
#define ALIBABACLOUD_SGW_SGWCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "SgwExport.h"
#include "model/ActivateAllInOneGatewayRequest.h"
#include "model/ActivateAllInOneGatewayResult.h"
#include "model/ActivateGatewayRequest.h"
#include "model/ActivateGatewayResult.h"
#include "model/AddSharesToExpressSyncRequest.h"
#include "model/AddSharesToExpressSyncResult.h"
#include "model/AddTagsToGatewayRequest.h"
#include "model/AddTagsToGatewayResult.h"
#include "model/CheckActivationKeyRequest.h"
#include "model/CheckActivationKeyResult.h"
#include "model/CheckBlockVolumeNameRequest.h"
#include "model/CheckBlockVolumeNameResult.h"
#include "model/CheckGatewayEssdSupportRequest.h"
#include "model/CheckGatewayEssdSupportResult.h"
#include "model/CheckMnsServiceRequest.h"
#include "model/CheckMnsServiceResult.h"
#include "model/CheckRoleRequest.h"
#include "model/CheckRoleResult.h"
#include "model/CheckSlrRoleRequest.h"
#include "model/CheckSlrRoleResult.h"
#include "model/CheckUpgradeVersionRequest.h"
#include "model/CheckUpgradeVersionResult.h"
#include "model/CreateCacheRequest.h"
#include "model/CreateCacheResult.h"
#include "model/CreateExpressSyncRequest.h"
#include "model/CreateExpressSyncResult.h"
#include "model/CreateGatewayRequest.h"
#include "model/CreateGatewayResult.h"
#include "model/CreateGatewayBlockVolumeRequest.h"
#include "model/CreateGatewayBlockVolumeResult.h"
#include "model/CreateGatewayCacheDiskRequest.h"
#include "model/CreateGatewayCacheDiskResult.h"
#include "model/CreateGatewayFileShareRequest.h"
#include "model/CreateGatewayFileShareResult.h"
#include "model/CreateGatewayLoggingRequest.h"
#include "model/CreateGatewayLoggingResult.h"
#include "model/CreateGatewaySMBUserRequest.h"
#include "model/CreateGatewaySMBUserResult.h"
#include "model/CreateStorageBundleRequest.h"
#include "model/CreateStorageBundleResult.h"
#include "model/DeleteExpressSyncRequest.h"
#include "model/DeleteExpressSyncResult.h"
#include "model/DeleteGatewayRequest.h"
#include "model/DeleteGatewayResult.h"
#include "model/DeleteGatewayBlockVolumesRequest.h"
#include "model/DeleteGatewayBlockVolumesResult.h"
#include "model/DeleteGatewayCacheDiskRequest.h"
#include "model/DeleteGatewayCacheDiskResult.h"
#include "model/DeleteGatewayFileSharesRequest.h"
#include "model/DeleteGatewayFileSharesResult.h"
#include "model/DeleteGatewayLoggingRequest.h"
#include "model/DeleteGatewayLoggingResult.h"
#include "model/DeleteGatewaySMBUserRequest.h"
#include "model/DeleteGatewaySMBUserResult.h"
#include "model/DeleteStorageBundleRequest.h"
#include "model/DeleteStorageBundleResult.h"
#include "model/DeployCacheDiskRequest.h"
#include "model/DeployCacheDiskResult.h"
#include "model/DeployGatewayRequest.h"
#include "model/DeployGatewayResult.h"
#include "model/DescribeAccountConfigRequest.h"
#include "model/DescribeAccountConfigResult.h"
#include "model/DescribeBlockVolumeSnapshotsRequest.h"
#include "model/DescribeBlockVolumeSnapshotsResult.h"
#include "model/DescribeDashboardRequest.h"
#include "model/DescribeDashboardResult.h"
#include "model/DescribeExpireCachesRequest.h"
#include "model/DescribeExpireCachesResult.h"
#include "model/DescribeExpressSyncSharesRequest.h"
#include "model/DescribeExpressSyncSharesResult.h"
#include "model/DescribeExpressSyncsRequest.h"
#include "model/DescribeExpressSyncsResult.h"
#include "model/DescribeGatewayRequest.h"
#include "model/DescribeGatewayResult.h"
#include "model/DescribeGatewayADInfoRequest.h"
#include "model/DescribeGatewayADInfoResult.h"
#include "model/DescribeGatewayActionsRequest.h"
#include "model/DescribeGatewayActionsResult.h"
#include "model/DescribeGatewayAuthInfoRequest.h"
#include "model/DescribeGatewayAuthInfoResult.h"
#include "model/DescribeGatewayBlockVolumesRequest.h"
#include "model/DescribeGatewayBlockVolumesResult.h"
#include "model/DescribeGatewayBucketCachesRequest.h"
#include "model/DescribeGatewayBucketCachesResult.h"
#include "model/DescribeGatewayCachesRequest.h"
#include "model/DescribeGatewayCachesResult.h"
#include "model/DescribeGatewayCapacityLimitRequest.h"
#include "model/DescribeGatewayCapacityLimitResult.h"
#include "model/DescribeGatewayCategoriesRequest.h"
#include "model/DescribeGatewayCategoriesResult.h"
#include "model/DescribeGatewayClassesRequest.h"
#include "model/DescribeGatewayClassesResult.h"
#include "model/DescribeGatewayCredentialRequest.h"
#include "model/DescribeGatewayCredentialResult.h"
#include "model/DescribeGatewayDNSRequest.h"
#include "model/DescribeGatewayDNSResult.h"
#include "model/DescribeGatewayFileSharesRequest.h"
#include "model/DescribeGatewayFileSharesResult.h"
#include "model/DescribeGatewayFileStatusRequest.h"
#include "model/DescribeGatewayFileStatusResult.h"
#include "model/DescribeGatewayImagesRequest.h"
#include "model/DescribeGatewayImagesResult.h"
#include "model/DescribeGatewayInfoRequest.h"
#include "model/DescribeGatewayInfoResult.h"
#include "model/DescribeGatewayLDAPInfoRequest.h"
#include "model/DescribeGatewayLDAPInfoResult.h"
#include "model/DescribeGatewayLocationsRequest.h"
#include "model/DescribeGatewayLocationsResult.h"
#include "model/DescribeGatewayLoggingRequest.h"
#include "model/DescribeGatewayLoggingResult.h"
#include "model/DescribeGatewayLogsRequest.h"
#include "model/DescribeGatewayLogsResult.h"
#include "model/DescribeGatewayModificationClassesRequest.h"
#include "model/DescribeGatewayModificationClassesResult.h"
#include "model/DescribeGatewaySMBUsersRequest.h"
#include "model/DescribeGatewaySMBUsersResult.h"
#include "model/DescribeGatewayStatisticsRequest.h"
#include "model/DescribeGatewayStatisticsResult.h"
#include "model/DescribeGatewayStockRequest.h"
#include "model/DescribeGatewayStockResult.h"
#include "model/DescribeGatewayTypesRequest.h"
#include "model/DescribeGatewayTypesResult.h"
#include "model/DescribeGatewaysRequest.h"
#include "model/DescribeGatewaysResult.h"
#include "model/DescribeGatewaysForCmsRequest.h"
#include "model/DescribeGatewaysForCmsResult.h"
#include "model/DescribeGatewaysTagsRequest.h"
#include "model/DescribeGatewaysTagsResult.h"
#include "model/DescribeKmsKeyRequest.h"
#include "model/DescribeKmsKeyResult.h"
#include "model/DescribeMqttConfigRequest.h"
#include "model/DescribeMqttConfigResult.h"
#include "model/DescribeOssBucketInfoRequest.h"
#include "model/DescribeOssBucketInfoResult.h"
#include "model/DescribeOssBucketsRequest.h"
#include "model/DescribeOssBucketsResult.h"
#include "model/DescribePayAsYouGoPriceRequest.h"
#include "model/DescribePayAsYouGoPriceResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeSharesBucketInfoForExpressSyncRequest.h"
#include "model/DescribeSharesBucketInfoForExpressSyncResult.h"
#include "model/DescribeStorageBundleRequest.h"
#include "model/DescribeStorageBundleResult.h"
#include "model/DescribeStorageBundlesRequest.h"
#include "model/DescribeStorageBundlesResult.h"
#include "model/DescribeSubscriptionPriceRequest.h"
#include "model/DescribeSubscriptionPriceResult.h"
#include "model/DescribeTasksRequest.h"
#include "model/DescribeTasksResult.h"
#include "model/DescribeUserBusinessStatusRequest.h"
#include "model/DescribeUserBusinessStatusResult.h"
#include "model/DescribeVSwitchesRequest.h"
#include "model/DescribeVSwitchesResult.h"
#include "model/DescribeVpcsRequest.h"
#include "model/DescribeVpcsResult.h"
#include "model/DescribeZonesRequest.h"
#include "model/DescribeZonesResult.h"
#include "model/DisableGatewayLoggingRequest.h"
#include "model/DisableGatewayLoggingResult.h"
#include "model/EnableGatewayLoggingRequest.h"
#include "model/EnableGatewayLoggingResult.h"
#include "model/ExpandCacheDiskRequest.h"
#include "model/ExpandCacheDiskResult.h"
#include "model/ExpandGatewayNetworkBandwidthRequest.h"
#include "model/ExpandGatewayNetworkBandwidthResult.h"
#include "model/GenerateGatewayTokenRequest.h"
#include "model/GenerateGatewayTokenResult.h"
#include "model/GenerateMqttTokenRequest.h"
#include "model/GenerateMqttTokenResult.h"
#include "model/GenerateStsTokenRequest.h"
#include "model/GenerateStsTokenResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ModifyGatewayRequest.h"
#include "model/ModifyGatewayResult.h"
#include "model/ModifyGatewayBlockVolumeRequest.h"
#include "model/ModifyGatewayBlockVolumeResult.h"
#include "model/ModifyGatewayClassRequest.h"
#include "model/ModifyGatewayClassResult.h"
#include "model/ModifyGatewayFileShareRequest.h"
#include "model/ModifyGatewayFileShareResult.h"
#include "model/ModifyStorageBundleRequest.h"
#include "model/ModifyStorageBundleResult.h"
#include "model/OperateGatewayRequest.h"
#include "model/OperateGatewayResult.h"
#include "model/ReleaseServiceRequest.h"
#include "model/ReleaseServiceResult.h"
#include "model/RemoveSharesFromExpressSyncRequest.h"
#include "model/RemoveSharesFromExpressSyncResult.h"
#include "model/RemoveTagsFromGatewayRequest.h"
#include "model/RemoveTagsFromGatewayResult.h"
#include "model/ReportBlockVolumesRequest.h"
#include "model/ReportBlockVolumesResult.h"
#include "model/ReportFileSharesRequest.h"
#include "model/ReportFileSharesResult.h"
#include "model/ReportGatewayInfoRequest.h"
#include "model/ReportGatewayInfoResult.h"
#include "model/ReportGatewayUsageRequest.h"
#include "model/ReportGatewayUsageResult.h"
#include "model/ResetGatewayPasswordRequest.h"
#include "model/ResetGatewayPasswordResult.h"
#include "model/RestartFileSharesRequest.h"
#include "model/RestartFileSharesResult.h"
#include "model/SetGatewayADInfoRequest.h"
#include "model/SetGatewayADInfoResult.h"
#include "model/SetGatewayDNSRequest.h"
#include "model/SetGatewayDNSResult.h"
#include "model/SetGatewayLDAPInfoRequest.h"
#include "model/SetGatewayLDAPInfoResult.h"
#include "model/SwitchGatewayExpirationPolicyRequest.h"
#include "model/SwitchGatewayExpirationPolicyResult.h"
#include "model/SwitchToSubscriptionRequest.h"
#include "model/SwitchToSubscriptionResult.h"
#include "model/TagResourcesRequest.h"
#include "model/TagResourcesResult.h"
#include "model/UntagResourcesRequest.h"
#include "model/UntagResourcesResult.h"
#include "model/UpdateGatewayBlockVolumeRequest.h"
#include "model/UpdateGatewayBlockVolumeResult.h"
#include "model/UpdateGatewayFileShareRequest.h"
#include "model/UpdateGatewayFileShareResult.h"
#include "model/UpgradeGatewayRequest.h"
#include "model/UpgradeGatewayResult.h"
#include "model/UploadGatewayLogRequest.h"
#include "model/UploadGatewayLogResult.h"
#include "model/ValidateExpressSyncConfigRequest.h"
#include "model/ValidateExpressSyncConfigResult.h"
#include "model/ValidateGatewayNameRequest.h"
#include "model/ValidateGatewayNameResult.h"
namespace AlibabaCloud
{
namespace Sgw
{
class ALIBABACLOUD_SGW_EXPORT SgwClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::ActivateAllInOneGatewayResult> ActivateAllInOneGatewayOutcome;
typedef std::future<ActivateAllInOneGatewayOutcome> ActivateAllInOneGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ActivateAllInOneGatewayRequest&, const ActivateAllInOneGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActivateAllInOneGatewayAsyncHandler;
typedef Outcome<Error, Model::ActivateGatewayResult> ActivateGatewayOutcome;
typedef std::future<ActivateGatewayOutcome> ActivateGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ActivateGatewayRequest&, const ActivateGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActivateGatewayAsyncHandler;
typedef Outcome<Error, Model::AddSharesToExpressSyncResult> AddSharesToExpressSyncOutcome;
typedef std::future<AddSharesToExpressSyncOutcome> AddSharesToExpressSyncOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::AddSharesToExpressSyncRequest&, const AddSharesToExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddSharesToExpressSyncAsyncHandler;
typedef Outcome<Error, Model::AddTagsToGatewayResult> AddTagsToGatewayOutcome;
typedef std::future<AddTagsToGatewayOutcome> AddTagsToGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::AddTagsToGatewayRequest&, const AddTagsToGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddTagsToGatewayAsyncHandler;
typedef Outcome<Error, Model::CheckActivationKeyResult> CheckActivationKeyOutcome;
typedef std::future<CheckActivationKeyOutcome> CheckActivationKeyOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CheckActivationKeyRequest&, const CheckActivationKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckActivationKeyAsyncHandler;
typedef Outcome<Error, Model::CheckBlockVolumeNameResult> CheckBlockVolumeNameOutcome;
typedef std::future<CheckBlockVolumeNameOutcome> CheckBlockVolumeNameOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CheckBlockVolumeNameRequest&, const CheckBlockVolumeNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckBlockVolumeNameAsyncHandler;
typedef Outcome<Error, Model::CheckGatewayEssdSupportResult> CheckGatewayEssdSupportOutcome;
typedef std::future<CheckGatewayEssdSupportOutcome> CheckGatewayEssdSupportOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CheckGatewayEssdSupportRequest&, const CheckGatewayEssdSupportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckGatewayEssdSupportAsyncHandler;
typedef Outcome<Error, Model::CheckMnsServiceResult> CheckMnsServiceOutcome;
typedef std::future<CheckMnsServiceOutcome> CheckMnsServiceOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CheckMnsServiceRequest&, const CheckMnsServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckMnsServiceAsyncHandler;
typedef Outcome<Error, Model::CheckRoleResult> CheckRoleOutcome;
typedef std::future<CheckRoleOutcome> CheckRoleOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CheckRoleRequest&, const CheckRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckRoleAsyncHandler;
typedef Outcome<Error, Model::CheckSlrRoleResult> CheckSlrRoleOutcome;
typedef std::future<CheckSlrRoleOutcome> CheckSlrRoleOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CheckSlrRoleRequest&, const CheckSlrRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckSlrRoleAsyncHandler;
typedef Outcome<Error, Model::CheckUpgradeVersionResult> CheckUpgradeVersionOutcome;
typedef std::future<CheckUpgradeVersionOutcome> CheckUpgradeVersionOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CheckUpgradeVersionRequest&, const CheckUpgradeVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckUpgradeVersionAsyncHandler;
typedef Outcome<Error, Model::CreateCacheResult> CreateCacheOutcome;
typedef std::future<CreateCacheOutcome> CreateCacheOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CreateCacheRequest&, const CreateCacheOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCacheAsyncHandler;
typedef Outcome<Error, Model::CreateExpressSyncResult> CreateExpressSyncOutcome;
typedef std::future<CreateExpressSyncOutcome> CreateExpressSyncOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CreateExpressSyncRequest&, const CreateExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateExpressSyncAsyncHandler;
typedef Outcome<Error, Model::CreateGatewayResult> CreateGatewayOutcome;
typedef std::future<CreateGatewayOutcome> CreateGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CreateGatewayRequest&, const CreateGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayAsyncHandler;
typedef Outcome<Error, Model::CreateGatewayBlockVolumeResult> CreateGatewayBlockVolumeOutcome;
typedef std::future<CreateGatewayBlockVolumeOutcome> CreateGatewayBlockVolumeOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CreateGatewayBlockVolumeRequest&, const CreateGatewayBlockVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayBlockVolumeAsyncHandler;
typedef Outcome<Error, Model::CreateGatewayCacheDiskResult> CreateGatewayCacheDiskOutcome;
typedef std::future<CreateGatewayCacheDiskOutcome> CreateGatewayCacheDiskOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CreateGatewayCacheDiskRequest&, const CreateGatewayCacheDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayCacheDiskAsyncHandler;
typedef Outcome<Error, Model::CreateGatewayFileShareResult> CreateGatewayFileShareOutcome;
typedef std::future<CreateGatewayFileShareOutcome> CreateGatewayFileShareOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CreateGatewayFileShareRequest&, const CreateGatewayFileShareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayFileShareAsyncHandler;
typedef Outcome<Error, Model::CreateGatewayLoggingResult> CreateGatewayLoggingOutcome;
typedef std::future<CreateGatewayLoggingOutcome> CreateGatewayLoggingOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CreateGatewayLoggingRequest&, const CreateGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayLoggingAsyncHandler;
typedef Outcome<Error, Model::CreateGatewaySMBUserResult> CreateGatewaySMBUserOutcome;
typedef std::future<CreateGatewaySMBUserOutcome> CreateGatewaySMBUserOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CreateGatewaySMBUserRequest&, const CreateGatewaySMBUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewaySMBUserAsyncHandler;
typedef Outcome<Error, Model::CreateStorageBundleResult> CreateStorageBundleOutcome;
typedef std::future<CreateStorageBundleOutcome> CreateStorageBundleOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::CreateStorageBundleRequest&, const CreateStorageBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateStorageBundleAsyncHandler;
typedef Outcome<Error, Model::DeleteExpressSyncResult> DeleteExpressSyncOutcome;
typedef std::future<DeleteExpressSyncOutcome> DeleteExpressSyncOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeleteExpressSyncRequest&, const DeleteExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteExpressSyncAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewayResult> DeleteGatewayOutcome;
typedef std::future<DeleteGatewayOutcome> DeleteGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeleteGatewayRequest&, const DeleteGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewayBlockVolumesResult> DeleteGatewayBlockVolumesOutcome;
typedef std::future<DeleteGatewayBlockVolumesOutcome> DeleteGatewayBlockVolumesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeleteGatewayBlockVolumesRequest&, const DeleteGatewayBlockVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayBlockVolumesAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewayCacheDiskResult> DeleteGatewayCacheDiskOutcome;
typedef std::future<DeleteGatewayCacheDiskOutcome> DeleteGatewayCacheDiskOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeleteGatewayCacheDiskRequest&, const DeleteGatewayCacheDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayCacheDiskAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewayFileSharesResult> DeleteGatewayFileSharesOutcome;
typedef std::future<DeleteGatewayFileSharesOutcome> DeleteGatewayFileSharesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeleteGatewayFileSharesRequest&, const DeleteGatewayFileSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayFileSharesAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewayLoggingResult> DeleteGatewayLoggingOutcome;
typedef std::future<DeleteGatewayLoggingOutcome> DeleteGatewayLoggingOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeleteGatewayLoggingRequest&, const DeleteGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayLoggingAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewaySMBUserResult> DeleteGatewaySMBUserOutcome;
typedef std::future<DeleteGatewaySMBUserOutcome> DeleteGatewaySMBUserOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeleteGatewaySMBUserRequest&, const DeleteGatewaySMBUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewaySMBUserAsyncHandler;
typedef Outcome<Error, Model::DeleteStorageBundleResult> DeleteStorageBundleOutcome;
typedef std::future<DeleteStorageBundleOutcome> DeleteStorageBundleOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeleteStorageBundleRequest&, const DeleteStorageBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteStorageBundleAsyncHandler;
typedef Outcome<Error, Model::DeployCacheDiskResult> DeployCacheDiskOutcome;
typedef std::future<DeployCacheDiskOutcome> DeployCacheDiskOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeployCacheDiskRequest&, const DeployCacheDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeployCacheDiskAsyncHandler;
typedef Outcome<Error, Model::DeployGatewayResult> DeployGatewayOutcome;
typedef std::future<DeployGatewayOutcome> DeployGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DeployGatewayRequest&, const DeployGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeployGatewayAsyncHandler;
typedef Outcome<Error, Model::DescribeAccountConfigResult> DescribeAccountConfigOutcome;
typedef std::future<DescribeAccountConfigOutcome> DescribeAccountConfigOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeAccountConfigRequest&, const DescribeAccountConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeBlockVolumeSnapshotsResult> DescribeBlockVolumeSnapshotsOutcome;
typedef std::future<DescribeBlockVolumeSnapshotsOutcome> DescribeBlockVolumeSnapshotsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeBlockVolumeSnapshotsRequest&, const DescribeBlockVolumeSnapshotsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBlockVolumeSnapshotsAsyncHandler;
typedef Outcome<Error, Model::DescribeDashboardResult> DescribeDashboardOutcome;
typedef std::future<DescribeDashboardOutcome> DescribeDashboardOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeDashboardRequest&, const DescribeDashboardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDashboardAsyncHandler;
typedef Outcome<Error, Model::DescribeExpireCachesResult> DescribeExpireCachesOutcome;
typedef std::future<DescribeExpireCachesOutcome> DescribeExpireCachesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeExpireCachesRequest&, const DescribeExpireCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeExpireCachesAsyncHandler;
typedef Outcome<Error, Model::DescribeExpressSyncSharesResult> DescribeExpressSyncSharesOutcome;
typedef std::future<DescribeExpressSyncSharesOutcome> DescribeExpressSyncSharesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeExpressSyncSharesRequest&, const DescribeExpressSyncSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeExpressSyncSharesAsyncHandler;
typedef Outcome<Error, Model::DescribeExpressSyncsResult> DescribeExpressSyncsOutcome;
typedef std::future<DescribeExpressSyncsOutcome> DescribeExpressSyncsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeExpressSyncsRequest&, const DescribeExpressSyncsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeExpressSyncsAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayResult> DescribeGatewayOutcome;
typedef std::future<DescribeGatewayOutcome> DescribeGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayRequest&, const DescribeGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayADInfoResult> DescribeGatewayADInfoOutcome;
typedef std::future<DescribeGatewayADInfoOutcome> DescribeGatewayADInfoOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayADInfoRequest&, const DescribeGatewayADInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayADInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayActionsResult> DescribeGatewayActionsOutcome;
typedef std::future<DescribeGatewayActionsOutcome> DescribeGatewayActionsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayActionsRequest&, const DescribeGatewayActionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayActionsAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayAuthInfoResult> DescribeGatewayAuthInfoOutcome;
typedef std::future<DescribeGatewayAuthInfoOutcome> DescribeGatewayAuthInfoOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayAuthInfoRequest&, const DescribeGatewayAuthInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayAuthInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayBlockVolumesResult> DescribeGatewayBlockVolumesOutcome;
typedef std::future<DescribeGatewayBlockVolumesOutcome> DescribeGatewayBlockVolumesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayBlockVolumesRequest&, const DescribeGatewayBlockVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayBlockVolumesAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayBucketCachesResult> DescribeGatewayBucketCachesOutcome;
typedef std::future<DescribeGatewayBucketCachesOutcome> DescribeGatewayBucketCachesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayBucketCachesRequest&, const DescribeGatewayBucketCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayBucketCachesAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayCachesResult> DescribeGatewayCachesOutcome;
typedef std::future<DescribeGatewayCachesOutcome> DescribeGatewayCachesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayCachesRequest&, const DescribeGatewayCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayCachesAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayCapacityLimitResult> DescribeGatewayCapacityLimitOutcome;
typedef std::future<DescribeGatewayCapacityLimitOutcome> DescribeGatewayCapacityLimitOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayCapacityLimitRequest&, const DescribeGatewayCapacityLimitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayCapacityLimitAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayCategoriesResult> DescribeGatewayCategoriesOutcome;
typedef std::future<DescribeGatewayCategoriesOutcome> DescribeGatewayCategoriesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayCategoriesRequest&, const DescribeGatewayCategoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayCategoriesAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayClassesResult> DescribeGatewayClassesOutcome;
typedef std::future<DescribeGatewayClassesOutcome> DescribeGatewayClassesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayClassesRequest&, const DescribeGatewayClassesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayClassesAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayCredentialResult> DescribeGatewayCredentialOutcome;
typedef std::future<DescribeGatewayCredentialOutcome> DescribeGatewayCredentialOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayCredentialRequest&, const DescribeGatewayCredentialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayCredentialAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayDNSResult> DescribeGatewayDNSOutcome;
typedef std::future<DescribeGatewayDNSOutcome> DescribeGatewayDNSOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayDNSRequest&, const DescribeGatewayDNSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayDNSAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayFileSharesResult> DescribeGatewayFileSharesOutcome;
typedef std::future<DescribeGatewayFileSharesOutcome> DescribeGatewayFileSharesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayFileSharesRequest&, const DescribeGatewayFileSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayFileSharesAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayFileStatusResult> DescribeGatewayFileStatusOutcome;
typedef std::future<DescribeGatewayFileStatusOutcome> DescribeGatewayFileStatusOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayFileStatusRequest&, const DescribeGatewayFileStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayFileStatusAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayImagesResult> DescribeGatewayImagesOutcome;
typedef std::future<DescribeGatewayImagesOutcome> DescribeGatewayImagesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayImagesRequest&, const DescribeGatewayImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayImagesAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayInfoResult> DescribeGatewayInfoOutcome;
typedef std::future<DescribeGatewayInfoOutcome> DescribeGatewayInfoOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayInfoRequest&, const DescribeGatewayInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayLDAPInfoResult> DescribeGatewayLDAPInfoOutcome;
typedef std::future<DescribeGatewayLDAPInfoOutcome> DescribeGatewayLDAPInfoOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayLDAPInfoRequest&, const DescribeGatewayLDAPInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayLDAPInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayLocationsResult> DescribeGatewayLocationsOutcome;
typedef std::future<DescribeGatewayLocationsOutcome> DescribeGatewayLocationsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayLocationsRequest&, const DescribeGatewayLocationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayLocationsAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayLoggingResult> DescribeGatewayLoggingOutcome;
typedef std::future<DescribeGatewayLoggingOutcome> DescribeGatewayLoggingOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayLoggingRequest&, const DescribeGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayLoggingAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayLogsResult> DescribeGatewayLogsOutcome;
typedef std::future<DescribeGatewayLogsOutcome> DescribeGatewayLogsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayLogsRequest&, const DescribeGatewayLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayLogsAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayModificationClassesResult> DescribeGatewayModificationClassesOutcome;
typedef std::future<DescribeGatewayModificationClassesOutcome> DescribeGatewayModificationClassesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayModificationClassesRequest&, const DescribeGatewayModificationClassesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayModificationClassesAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewaySMBUsersResult> DescribeGatewaySMBUsersOutcome;
typedef std::future<DescribeGatewaySMBUsersOutcome> DescribeGatewaySMBUsersOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewaySMBUsersRequest&, const DescribeGatewaySMBUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewaySMBUsersAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayStatisticsResult> DescribeGatewayStatisticsOutcome;
typedef std::future<DescribeGatewayStatisticsOutcome> DescribeGatewayStatisticsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayStatisticsRequest&, const DescribeGatewayStatisticsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayStatisticsAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayStockResult> DescribeGatewayStockOutcome;
typedef std::future<DescribeGatewayStockOutcome> DescribeGatewayStockOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayStockRequest&, const DescribeGatewayStockOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayStockAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewayTypesResult> DescribeGatewayTypesOutcome;
typedef std::future<DescribeGatewayTypesOutcome> DescribeGatewayTypesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewayTypesRequest&, const DescribeGatewayTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewayTypesAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewaysResult> DescribeGatewaysOutcome;
typedef std::future<DescribeGatewaysOutcome> DescribeGatewaysOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewaysRequest&, const DescribeGatewaysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewaysAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewaysForCmsResult> DescribeGatewaysForCmsOutcome;
typedef std::future<DescribeGatewaysForCmsOutcome> DescribeGatewaysForCmsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewaysForCmsRequest&, const DescribeGatewaysForCmsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewaysForCmsAsyncHandler;
typedef Outcome<Error, Model::DescribeGatewaysTagsResult> DescribeGatewaysTagsOutcome;
typedef std::future<DescribeGatewaysTagsOutcome> DescribeGatewaysTagsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeGatewaysTagsRequest&, const DescribeGatewaysTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGatewaysTagsAsyncHandler;
typedef Outcome<Error, Model::DescribeKmsKeyResult> DescribeKmsKeyOutcome;
typedef std::future<DescribeKmsKeyOutcome> DescribeKmsKeyOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeKmsKeyRequest&, const DescribeKmsKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeKmsKeyAsyncHandler;
typedef Outcome<Error, Model::DescribeMqttConfigResult> DescribeMqttConfigOutcome;
typedef std::future<DescribeMqttConfigOutcome> DescribeMqttConfigOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeMqttConfigRequest&, const DescribeMqttConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMqttConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeOssBucketInfoResult> DescribeOssBucketInfoOutcome;
typedef std::future<DescribeOssBucketInfoOutcome> DescribeOssBucketInfoOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeOssBucketInfoRequest&, const DescribeOssBucketInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOssBucketInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeOssBucketsResult> DescribeOssBucketsOutcome;
typedef std::future<DescribeOssBucketsOutcome> DescribeOssBucketsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeOssBucketsRequest&, const DescribeOssBucketsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOssBucketsAsyncHandler;
typedef Outcome<Error, Model::DescribePayAsYouGoPriceResult> DescribePayAsYouGoPriceOutcome;
typedef std::future<DescribePayAsYouGoPriceOutcome> DescribePayAsYouGoPriceOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribePayAsYouGoPriceRequest&, const DescribePayAsYouGoPriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePayAsYouGoPriceAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeSharesBucketInfoForExpressSyncResult> DescribeSharesBucketInfoForExpressSyncOutcome;
typedef std::future<DescribeSharesBucketInfoForExpressSyncOutcome> DescribeSharesBucketInfoForExpressSyncOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeSharesBucketInfoForExpressSyncRequest&, const DescribeSharesBucketInfoForExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSharesBucketInfoForExpressSyncAsyncHandler;
typedef Outcome<Error, Model::DescribeStorageBundleResult> DescribeStorageBundleOutcome;
typedef std::future<DescribeStorageBundleOutcome> DescribeStorageBundleOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeStorageBundleRequest&, const DescribeStorageBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStorageBundleAsyncHandler;
typedef Outcome<Error, Model::DescribeStorageBundlesResult> DescribeStorageBundlesOutcome;
typedef std::future<DescribeStorageBundlesOutcome> DescribeStorageBundlesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeStorageBundlesRequest&, const DescribeStorageBundlesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStorageBundlesAsyncHandler;
typedef Outcome<Error, Model::DescribeSubscriptionPriceResult> DescribeSubscriptionPriceOutcome;
typedef std::future<DescribeSubscriptionPriceOutcome> DescribeSubscriptionPriceOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeSubscriptionPriceRequest&, const DescribeSubscriptionPriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSubscriptionPriceAsyncHandler;
typedef Outcome<Error, Model::DescribeTasksResult> DescribeTasksOutcome;
typedef std::future<DescribeTasksOutcome> DescribeTasksOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeTasksRequest&, const DescribeTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTasksAsyncHandler;
typedef Outcome<Error, Model::DescribeUserBusinessStatusResult> DescribeUserBusinessStatusOutcome;
typedef std::future<DescribeUserBusinessStatusOutcome> DescribeUserBusinessStatusOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeUserBusinessStatusRequest&, const DescribeUserBusinessStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserBusinessStatusAsyncHandler;
typedef Outcome<Error, Model::DescribeVSwitchesResult> DescribeVSwitchesOutcome;
typedef std::future<DescribeVSwitchesOutcome> DescribeVSwitchesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeVSwitchesRequest&, const DescribeVSwitchesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVSwitchesAsyncHandler;
typedef Outcome<Error, Model::DescribeVpcsResult> DescribeVpcsOutcome;
typedef std::future<DescribeVpcsOutcome> DescribeVpcsOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeVpcsRequest&, const DescribeVpcsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVpcsAsyncHandler;
typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
typedef Outcome<Error, Model::DisableGatewayLoggingResult> DisableGatewayLoggingOutcome;
typedef std::future<DisableGatewayLoggingOutcome> DisableGatewayLoggingOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::DisableGatewayLoggingRequest&, const DisableGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableGatewayLoggingAsyncHandler;
typedef Outcome<Error, Model::EnableGatewayLoggingResult> EnableGatewayLoggingOutcome;
typedef std::future<EnableGatewayLoggingOutcome> EnableGatewayLoggingOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::EnableGatewayLoggingRequest&, const EnableGatewayLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableGatewayLoggingAsyncHandler;
typedef Outcome<Error, Model::ExpandCacheDiskResult> ExpandCacheDiskOutcome;
typedef std::future<ExpandCacheDiskOutcome> ExpandCacheDiskOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ExpandCacheDiskRequest&, const ExpandCacheDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExpandCacheDiskAsyncHandler;
typedef Outcome<Error, Model::ExpandGatewayNetworkBandwidthResult> ExpandGatewayNetworkBandwidthOutcome;
typedef std::future<ExpandGatewayNetworkBandwidthOutcome> ExpandGatewayNetworkBandwidthOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ExpandGatewayNetworkBandwidthRequest&, const ExpandGatewayNetworkBandwidthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExpandGatewayNetworkBandwidthAsyncHandler;
typedef Outcome<Error, Model::GenerateGatewayTokenResult> GenerateGatewayTokenOutcome;
typedef std::future<GenerateGatewayTokenOutcome> GenerateGatewayTokenOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::GenerateGatewayTokenRequest&, const GenerateGatewayTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateGatewayTokenAsyncHandler;
typedef Outcome<Error, Model::GenerateMqttTokenResult> GenerateMqttTokenOutcome;
typedef std::future<GenerateMqttTokenOutcome> GenerateMqttTokenOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::GenerateMqttTokenRequest&, const GenerateMqttTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateMqttTokenAsyncHandler;
typedef Outcome<Error, Model::GenerateStsTokenResult> GenerateStsTokenOutcome;
typedef std::future<GenerateStsTokenOutcome> GenerateStsTokenOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::GenerateStsTokenRequest&, const GenerateStsTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateStsTokenAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
typedef Outcome<Error, Model::ModifyGatewayResult> ModifyGatewayOutcome;
typedef std::future<ModifyGatewayOutcome> ModifyGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ModifyGatewayRequest&, const ModifyGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayAsyncHandler;
typedef Outcome<Error, Model::ModifyGatewayBlockVolumeResult> ModifyGatewayBlockVolumeOutcome;
typedef std::future<ModifyGatewayBlockVolumeOutcome> ModifyGatewayBlockVolumeOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ModifyGatewayBlockVolumeRequest&, const ModifyGatewayBlockVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayBlockVolumeAsyncHandler;
typedef Outcome<Error, Model::ModifyGatewayClassResult> ModifyGatewayClassOutcome;
typedef std::future<ModifyGatewayClassOutcome> ModifyGatewayClassOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ModifyGatewayClassRequest&, const ModifyGatewayClassOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayClassAsyncHandler;
typedef Outcome<Error, Model::ModifyGatewayFileShareResult> ModifyGatewayFileShareOutcome;
typedef std::future<ModifyGatewayFileShareOutcome> ModifyGatewayFileShareOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ModifyGatewayFileShareRequest&, const ModifyGatewayFileShareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayFileShareAsyncHandler;
typedef Outcome<Error, Model::ModifyStorageBundleResult> ModifyStorageBundleOutcome;
typedef std::future<ModifyStorageBundleOutcome> ModifyStorageBundleOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ModifyStorageBundleRequest&, const ModifyStorageBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyStorageBundleAsyncHandler;
typedef Outcome<Error, Model::OperateGatewayResult> OperateGatewayOutcome;
typedef std::future<OperateGatewayOutcome> OperateGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::OperateGatewayRequest&, const OperateGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OperateGatewayAsyncHandler;
typedef Outcome<Error, Model::ReleaseServiceResult> ReleaseServiceOutcome;
typedef std::future<ReleaseServiceOutcome> ReleaseServiceOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ReleaseServiceRequest&, const ReleaseServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseServiceAsyncHandler;
typedef Outcome<Error, Model::RemoveSharesFromExpressSyncResult> RemoveSharesFromExpressSyncOutcome;
typedef std::future<RemoveSharesFromExpressSyncOutcome> RemoveSharesFromExpressSyncOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::RemoveSharesFromExpressSyncRequest&, const RemoveSharesFromExpressSyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveSharesFromExpressSyncAsyncHandler;
typedef Outcome<Error, Model::RemoveTagsFromGatewayResult> RemoveTagsFromGatewayOutcome;
typedef std::future<RemoveTagsFromGatewayOutcome> RemoveTagsFromGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::RemoveTagsFromGatewayRequest&, const RemoveTagsFromGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveTagsFromGatewayAsyncHandler;
typedef Outcome<Error, Model::ReportBlockVolumesResult> ReportBlockVolumesOutcome;
typedef std::future<ReportBlockVolumesOutcome> ReportBlockVolumesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ReportBlockVolumesRequest&, const ReportBlockVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReportBlockVolumesAsyncHandler;
typedef Outcome<Error, Model::ReportFileSharesResult> ReportFileSharesOutcome;
typedef std::future<ReportFileSharesOutcome> ReportFileSharesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ReportFileSharesRequest&, const ReportFileSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReportFileSharesAsyncHandler;
typedef Outcome<Error, Model::ReportGatewayInfoResult> ReportGatewayInfoOutcome;
typedef std::future<ReportGatewayInfoOutcome> ReportGatewayInfoOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ReportGatewayInfoRequest&, const ReportGatewayInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReportGatewayInfoAsyncHandler;
typedef Outcome<Error, Model::ReportGatewayUsageResult> ReportGatewayUsageOutcome;
typedef std::future<ReportGatewayUsageOutcome> ReportGatewayUsageOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ReportGatewayUsageRequest&, const ReportGatewayUsageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReportGatewayUsageAsyncHandler;
typedef Outcome<Error, Model::ResetGatewayPasswordResult> ResetGatewayPasswordOutcome;
typedef std::future<ResetGatewayPasswordOutcome> ResetGatewayPasswordOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ResetGatewayPasswordRequest&, const ResetGatewayPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetGatewayPasswordAsyncHandler;
typedef Outcome<Error, Model::RestartFileSharesResult> RestartFileSharesOutcome;
typedef std::future<RestartFileSharesOutcome> RestartFileSharesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::RestartFileSharesRequest&, const RestartFileSharesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartFileSharesAsyncHandler;
typedef Outcome<Error, Model::SetGatewayADInfoResult> SetGatewayADInfoOutcome;
typedef std::future<SetGatewayADInfoOutcome> SetGatewayADInfoOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::SetGatewayADInfoRequest&, const SetGatewayADInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGatewayADInfoAsyncHandler;
typedef Outcome<Error, Model::SetGatewayDNSResult> SetGatewayDNSOutcome;
typedef std::future<SetGatewayDNSOutcome> SetGatewayDNSOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::SetGatewayDNSRequest&, const SetGatewayDNSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGatewayDNSAsyncHandler;
typedef Outcome<Error, Model::SetGatewayLDAPInfoResult> SetGatewayLDAPInfoOutcome;
typedef std::future<SetGatewayLDAPInfoOutcome> SetGatewayLDAPInfoOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::SetGatewayLDAPInfoRequest&, const SetGatewayLDAPInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGatewayLDAPInfoAsyncHandler;
typedef Outcome<Error, Model::SwitchGatewayExpirationPolicyResult> SwitchGatewayExpirationPolicyOutcome;
typedef std::future<SwitchGatewayExpirationPolicyOutcome> SwitchGatewayExpirationPolicyOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::SwitchGatewayExpirationPolicyRequest&, const SwitchGatewayExpirationPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwitchGatewayExpirationPolicyAsyncHandler;
typedef Outcome<Error, Model::SwitchToSubscriptionResult> SwitchToSubscriptionOutcome;
typedef std::future<SwitchToSubscriptionOutcome> SwitchToSubscriptionOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::SwitchToSubscriptionRequest&, const SwitchToSubscriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwitchToSubscriptionAsyncHandler;
typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
typedef Outcome<Error, Model::UpdateGatewayBlockVolumeResult> UpdateGatewayBlockVolumeOutcome;
typedef std::future<UpdateGatewayBlockVolumeOutcome> UpdateGatewayBlockVolumeOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::UpdateGatewayBlockVolumeRequest&, const UpdateGatewayBlockVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayBlockVolumeAsyncHandler;
typedef Outcome<Error, Model::UpdateGatewayFileShareResult> UpdateGatewayFileShareOutcome;
typedef std::future<UpdateGatewayFileShareOutcome> UpdateGatewayFileShareOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::UpdateGatewayFileShareRequest&, const UpdateGatewayFileShareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayFileShareAsyncHandler;
typedef Outcome<Error, Model::UpgradeGatewayResult> UpgradeGatewayOutcome;
typedef std::future<UpgradeGatewayOutcome> UpgradeGatewayOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::UpgradeGatewayRequest&, const UpgradeGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeGatewayAsyncHandler;
typedef Outcome<Error, Model::UploadGatewayLogResult> UploadGatewayLogOutcome;
typedef std::future<UploadGatewayLogOutcome> UploadGatewayLogOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::UploadGatewayLogRequest&, const UploadGatewayLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadGatewayLogAsyncHandler;
typedef Outcome<Error, Model::ValidateExpressSyncConfigResult> ValidateExpressSyncConfigOutcome;
typedef std::future<ValidateExpressSyncConfigOutcome> ValidateExpressSyncConfigOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ValidateExpressSyncConfigRequest&, const ValidateExpressSyncConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateExpressSyncConfigAsyncHandler;
typedef Outcome<Error, Model::ValidateGatewayNameResult> ValidateGatewayNameOutcome;
typedef std::future<ValidateGatewayNameOutcome> ValidateGatewayNameOutcomeCallable;
typedef std::function<void(const SgwClient*, const Model::ValidateGatewayNameRequest&, const ValidateGatewayNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateGatewayNameAsyncHandler;
SgwClient(const Credentials &credentials, const ClientConfiguration &configuration);
SgwClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
SgwClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~SgwClient();
ActivateAllInOneGatewayOutcome activateAllInOneGateway(const Model::ActivateAllInOneGatewayRequest &request)const;
void activateAllInOneGatewayAsync(const Model::ActivateAllInOneGatewayRequest& request, const ActivateAllInOneGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ActivateAllInOneGatewayOutcomeCallable activateAllInOneGatewayCallable(const Model::ActivateAllInOneGatewayRequest& request) const;
ActivateGatewayOutcome activateGateway(const Model::ActivateGatewayRequest &request)const;
void activateGatewayAsync(const Model::ActivateGatewayRequest& request, const ActivateGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ActivateGatewayOutcomeCallable activateGatewayCallable(const Model::ActivateGatewayRequest& request) const;
AddSharesToExpressSyncOutcome addSharesToExpressSync(const Model::AddSharesToExpressSyncRequest &request)const;
void addSharesToExpressSyncAsync(const Model::AddSharesToExpressSyncRequest& request, const AddSharesToExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddSharesToExpressSyncOutcomeCallable addSharesToExpressSyncCallable(const Model::AddSharesToExpressSyncRequest& request) const;
AddTagsToGatewayOutcome addTagsToGateway(const Model::AddTagsToGatewayRequest &request)const;
void addTagsToGatewayAsync(const Model::AddTagsToGatewayRequest& request, const AddTagsToGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddTagsToGatewayOutcomeCallable addTagsToGatewayCallable(const Model::AddTagsToGatewayRequest& request) const;
CheckActivationKeyOutcome checkActivationKey(const Model::CheckActivationKeyRequest &request)const;
void checkActivationKeyAsync(const Model::CheckActivationKeyRequest& request, const CheckActivationKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckActivationKeyOutcomeCallable checkActivationKeyCallable(const Model::CheckActivationKeyRequest& request) const;
CheckBlockVolumeNameOutcome checkBlockVolumeName(const Model::CheckBlockVolumeNameRequest &request)const;
void checkBlockVolumeNameAsync(const Model::CheckBlockVolumeNameRequest& request, const CheckBlockVolumeNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckBlockVolumeNameOutcomeCallable checkBlockVolumeNameCallable(const Model::CheckBlockVolumeNameRequest& request) const;
CheckGatewayEssdSupportOutcome checkGatewayEssdSupport(const Model::CheckGatewayEssdSupportRequest &request)const;
void checkGatewayEssdSupportAsync(const Model::CheckGatewayEssdSupportRequest& request, const CheckGatewayEssdSupportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckGatewayEssdSupportOutcomeCallable checkGatewayEssdSupportCallable(const Model::CheckGatewayEssdSupportRequest& request) const;
CheckMnsServiceOutcome checkMnsService(const Model::CheckMnsServiceRequest &request)const;
void checkMnsServiceAsync(const Model::CheckMnsServiceRequest& request, const CheckMnsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckMnsServiceOutcomeCallable checkMnsServiceCallable(const Model::CheckMnsServiceRequest& request) const;
CheckRoleOutcome checkRole(const Model::CheckRoleRequest &request)const;
void checkRoleAsync(const Model::CheckRoleRequest& request, const CheckRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckRoleOutcomeCallable checkRoleCallable(const Model::CheckRoleRequest& request) const;
CheckSlrRoleOutcome checkSlrRole(const Model::CheckSlrRoleRequest &request)const;
void checkSlrRoleAsync(const Model::CheckSlrRoleRequest& request, const CheckSlrRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckSlrRoleOutcomeCallable checkSlrRoleCallable(const Model::CheckSlrRoleRequest& request) const;
CheckUpgradeVersionOutcome checkUpgradeVersion(const Model::CheckUpgradeVersionRequest &request)const;
void checkUpgradeVersionAsync(const Model::CheckUpgradeVersionRequest& request, const CheckUpgradeVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckUpgradeVersionOutcomeCallable checkUpgradeVersionCallable(const Model::CheckUpgradeVersionRequest& request) const;
CreateCacheOutcome createCache(const Model::CreateCacheRequest &request)const;
void createCacheAsync(const Model::CreateCacheRequest& request, const CreateCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCacheOutcomeCallable createCacheCallable(const Model::CreateCacheRequest& request) const;
CreateExpressSyncOutcome createExpressSync(const Model::CreateExpressSyncRequest &request)const;
void createExpressSyncAsync(const Model::CreateExpressSyncRequest& request, const CreateExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateExpressSyncOutcomeCallable createExpressSyncCallable(const Model::CreateExpressSyncRequest& request) const;
CreateGatewayOutcome createGateway(const Model::CreateGatewayRequest &request)const;
void createGatewayAsync(const Model::CreateGatewayRequest& request, const CreateGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateGatewayOutcomeCallable createGatewayCallable(const Model::CreateGatewayRequest& request) const;
CreateGatewayBlockVolumeOutcome createGatewayBlockVolume(const Model::CreateGatewayBlockVolumeRequest &request)const;
void createGatewayBlockVolumeAsync(const Model::CreateGatewayBlockVolumeRequest& request, const CreateGatewayBlockVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateGatewayBlockVolumeOutcomeCallable createGatewayBlockVolumeCallable(const Model::CreateGatewayBlockVolumeRequest& request) const;
CreateGatewayCacheDiskOutcome createGatewayCacheDisk(const Model::CreateGatewayCacheDiskRequest &request)const;
void createGatewayCacheDiskAsync(const Model::CreateGatewayCacheDiskRequest& request, const CreateGatewayCacheDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateGatewayCacheDiskOutcomeCallable createGatewayCacheDiskCallable(const Model::CreateGatewayCacheDiskRequest& request) const;
CreateGatewayFileShareOutcome createGatewayFileShare(const Model::CreateGatewayFileShareRequest &request)const;
void createGatewayFileShareAsync(const Model::CreateGatewayFileShareRequest& request, const CreateGatewayFileShareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateGatewayFileShareOutcomeCallable createGatewayFileShareCallable(const Model::CreateGatewayFileShareRequest& request) const;
CreateGatewayLoggingOutcome createGatewayLogging(const Model::CreateGatewayLoggingRequest &request)const;
void createGatewayLoggingAsync(const Model::CreateGatewayLoggingRequest& request, const CreateGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateGatewayLoggingOutcomeCallable createGatewayLoggingCallable(const Model::CreateGatewayLoggingRequest& request) const;
CreateGatewaySMBUserOutcome createGatewaySMBUser(const Model::CreateGatewaySMBUserRequest &request)const;
void createGatewaySMBUserAsync(const Model::CreateGatewaySMBUserRequest& request, const CreateGatewaySMBUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateGatewaySMBUserOutcomeCallable createGatewaySMBUserCallable(const Model::CreateGatewaySMBUserRequest& request) const;
CreateStorageBundleOutcome createStorageBundle(const Model::CreateStorageBundleRequest &request)const;
void createStorageBundleAsync(const Model::CreateStorageBundleRequest& request, const CreateStorageBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateStorageBundleOutcomeCallable createStorageBundleCallable(const Model::CreateStorageBundleRequest& request) const;
DeleteExpressSyncOutcome deleteExpressSync(const Model::DeleteExpressSyncRequest &request)const;
void deleteExpressSyncAsync(const Model::DeleteExpressSyncRequest& request, const DeleteExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteExpressSyncOutcomeCallable deleteExpressSyncCallable(const Model::DeleteExpressSyncRequest& request) const;
DeleteGatewayOutcome deleteGateway(const Model::DeleteGatewayRequest &request)const;
void deleteGatewayAsync(const Model::DeleteGatewayRequest& request, const DeleteGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayOutcomeCallable deleteGatewayCallable(const Model::DeleteGatewayRequest& request) const;
DeleteGatewayBlockVolumesOutcome deleteGatewayBlockVolumes(const Model::DeleteGatewayBlockVolumesRequest &request)const;
void deleteGatewayBlockVolumesAsync(const Model::DeleteGatewayBlockVolumesRequest& request, const DeleteGatewayBlockVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayBlockVolumesOutcomeCallable deleteGatewayBlockVolumesCallable(const Model::DeleteGatewayBlockVolumesRequest& request) const;
DeleteGatewayCacheDiskOutcome deleteGatewayCacheDisk(const Model::DeleteGatewayCacheDiskRequest &request)const;
void deleteGatewayCacheDiskAsync(const Model::DeleteGatewayCacheDiskRequest& request, const DeleteGatewayCacheDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayCacheDiskOutcomeCallable deleteGatewayCacheDiskCallable(const Model::DeleteGatewayCacheDiskRequest& request) const;
DeleteGatewayFileSharesOutcome deleteGatewayFileShares(const Model::DeleteGatewayFileSharesRequest &request)const;
void deleteGatewayFileSharesAsync(const Model::DeleteGatewayFileSharesRequest& request, const DeleteGatewayFileSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayFileSharesOutcomeCallable deleteGatewayFileSharesCallable(const Model::DeleteGatewayFileSharesRequest& request) const;
DeleteGatewayLoggingOutcome deleteGatewayLogging(const Model::DeleteGatewayLoggingRequest &request)const;
void deleteGatewayLoggingAsync(const Model::DeleteGatewayLoggingRequest& request, const DeleteGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayLoggingOutcomeCallable deleteGatewayLoggingCallable(const Model::DeleteGatewayLoggingRequest& request) const;
DeleteGatewaySMBUserOutcome deleteGatewaySMBUser(const Model::DeleteGatewaySMBUserRequest &request)const;
void deleteGatewaySMBUserAsync(const Model::DeleteGatewaySMBUserRequest& request, const DeleteGatewaySMBUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewaySMBUserOutcomeCallable deleteGatewaySMBUserCallable(const Model::DeleteGatewaySMBUserRequest& request) const;
DeleteStorageBundleOutcome deleteStorageBundle(const Model::DeleteStorageBundleRequest &request)const;
void deleteStorageBundleAsync(const Model::DeleteStorageBundleRequest& request, const DeleteStorageBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteStorageBundleOutcomeCallable deleteStorageBundleCallable(const Model::DeleteStorageBundleRequest& request) const;
DeployCacheDiskOutcome deployCacheDisk(const Model::DeployCacheDiskRequest &request)const;
void deployCacheDiskAsync(const Model::DeployCacheDiskRequest& request, const DeployCacheDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeployCacheDiskOutcomeCallable deployCacheDiskCallable(const Model::DeployCacheDiskRequest& request) const;
DeployGatewayOutcome deployGateway(const Model::DeployGatewayRequest &request)const;
void deployGatewayAsync(const Model::DeployGatewayRequest& request, const DeployGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeployGatewayOutcomeCallable deployGatewayCallable(const Model::DeployGatewayRequest& request) const;
DescribeAccountConfigOutcome describeAccountConfig(const Model::DescribeAccountConfigRequest &request)const;
void describeAccountConfigAsync(const Model::DescribeAccountConfigRequest& request, const DescribeAccountConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccountConfigOutcomeCallable describeAccountConfigCallable(const Model::DescribeAccountConfigRequest& request) const;
DescribeBlockVolumeSnapshotsOutcome describeBlockVolumeSnapshots(const Model::DescribeBlockVolumeSnapshotsRequest &request)const;
void describeBlockVolumeSnapshotsAsync(const Model::DescribeBlockVolumeSnapshotsRequest& request, const DescribeBlockVolumeSnapshotsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBlockVolumeSnapshotsOutcomeCallable describeBlockVolumeSnapshotsCallable(const Model::DescribeBlockVolumeSnapshotsRequest& request) const;
DescribeDashboardOutcome describeDashboard(const Model::DescribeDashboardRequest &request)const;
void describeDashboardAsync(const Model::DescribeDashboardRequest& request, const DescribeDashboardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDashboardOutcomeCallable describeDashboardCallable(const Model::DescribeDashboardRequest& request) const;
DescribeExpireCachesOutcome describeExpireCaches(const Model::DescribeExpireCachesRequest &request)const;
void describeExpireCachesAsync(const Model::DescribeExpireCachesRequest& request, const DescribeExpireCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeExpireCachesOutcomeCallable describeExpireCachesCallable(const Model::DescribeExpireCachesRequest& request) const;
DescribeExpressSyncSharesOutcome describeExpressSyncShares(const Model::DescribeExpressSyncSharesRequest &request)const;
void describeExpressSyncSharesAsync(const Model::DescribeExpressSyncSharesRequest& request, const DescribeExpressSyncSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeExpressSyncSharesOutcomeCallable describeExpressSyncSharesCallable(const Model::DescribeExpressSyncSharesRequest& request) const;
DescribeExpressSyncsOutcome describeExpressSyncs(const Model::DescribeExpressSyncsRequest &request)const;
void describeExpressSyncsAsync(const Model::DescribeExpressSyncsRequest& request, const DescribeExpressSyncsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeExpressSyncsOutcomeCallable describeExpressSyncsCallable(const Model::DescribeExpressSyncsRequest& request) const;
DescribeGatewayOutcome describeGateway(const Model::DescribeGatewayRequest &request)const;
void describeGatewayAsync(const Model::DescribeGatewayRequest& request, const DescribeGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayOutcomeCallable describeGatewayCallable(const Model::DescribeGatewayRequest& request) const;
DescribeGatewayADInfoOutcome describeGatewayADInfo(const Model::DescribeGatewayADInfoRequest &request)const;
void describeGatewayADInfoAsync(const Model::DescribeGatewayADInfoRequest& request, const DescribeGatewayADInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayADInfoOutcomeCallable describeGatewayADInfoCallable(const Model::DescribeGatewayADInfoRequest& request) const;
DescribeGatewayActionsOutcome describeGatewayActions(const Model::DescribeGatewayActionsRequest &request)const;
void describeGatewayActionsAsync(const Model::DescribeGatewayActionsRequest& request, const DescribeGatewayActionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayActionsOutcomeCallable describeGatewayActionsCallable(const Model::DescribeGatewayActionsRequest& request) const;
DescribeGatewayAuthInfoOutcome describeGatewayAuthInfo(const Model::DescribeGatewayAuthInfoRequest &request)const;
void describeGatewayAuthInfoAsync(const Model::DescribeGatewayAuthInfoRequest& request, const DescribeGatewayAuthInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayAuthInfoOutcomeCallable describeGatewayAuthInfoCallable(const Model::DescribeGatewayAuthInfoRequest& request) const;
DescribeGatewayBlockVolumesOutcome describeGatewayBlockVolumes(const Model::DescribeGatewayBlockVolumesRequest &request)const;
void describeGatewayBlockVolumesAsync(const Model::DescribeGatewayBlockVolumesRequest& request, const DescribeGatewayBlockVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayBlockVolumesOutcomeCallable describeGatewayBlockVolumesCallable(const Model::DescribeGatewayBlockVolumesRequest& request) const;
DescribeGatewayBucketCachesOutcome describeGatewayBucketCaches(const Model::DescribeGatewayBucketCachesRequest &request)const;
void describeGatewayBucketCachesAsync(const Model::DescribeGatewayBucketCachesRequest& request, const DescribeGatewayBucketCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayBucketCachesOutcomeCallable describeGatewayBucketCachesCallable(const Model::DescribeGatewayBucketCachesRequest& request) const;
DescribeGatewayCachesOutcome describeGatewayCaches(const Model::DescribeGatewayCachesRequest &request)const;
void describeGatewayCachesAsync(const Model::DescribeGatewayCachesRequest& request, const DescribeGatewayCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayCachesOutcomeCallable describeGatewayCachesCallable(const Model::DescribeGatewayCachesRequest& request) const;
DescribeGatewayCapacityLimitOutcome describeGatewayCapacityLimit(const Model::DescribeGatewayCapacityLimitRequest &request)const;
void describeGatewayCapacityLimitAsync(const Model::DescribeGatewayCapacityLimitRequest& request, const DescribeGatewayCapacityLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayCapacityLimitOutcomeCallable describeGatewayCapacityLimitCallable(const Model::DescribeGatewayCapacityLimitRequest& request) const;
DescribeGatewayCategoriesOutcome describeGatewayCategories(const Model::DescribeGatewayCategoriesRequest &request)const;
void describeGatewayCategoriesAsync(const Model::DescribeGatewayCategoriesRequest& request, const DescribeGatewayCategoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayCategoriesOutcomeCallable describeGatewayCategoriesCallable(const Model::DescribeGatewayCategoriesRequest& request) const;
DescribeGatewayClassesOutcome describeGatewayClasses(const Model::DescribeGatewayClassesRequest &request)const;
void describeGatewayClassesAsync(const Model::DescribeGatewayClassesRequest& request, const DescribeGatewayClassesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayClassesOutcomeCallable describeGatewayClassesCallable(const Model::DescribeGatewayClassesRequest& request) const;
DescribeGatewayCredentialOutcome describeGatewayCredential(const Model::DescribeGatewayCredentialRequest &request)const;
void describeGatewayCredentialAsync(const Model::DescribeGatewayCredentialRequest& request, const DescribeGatewayCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayCredentialOutcomeCallable describeGatewayCredentialCallable(const Model::DescribeGatewayCredentialRequest& request) const;
DescribeGatewayDNSOutcome describeGatewayDNS(const Model::DescribeGatewayDNSRequest &request)const;
void describeGatewayDNSAsync(const Model::DescribeGatewayDNSRequest& request, const DescribeGatewayDNSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayDNSOutcomeCallable describeGatewayDNSCallable(const Model::DescribeGatewayDNSRequest& request) const;
DescribeGatewayFileSharesOutcome describeGatewayFileShares(const Model::DescribeGatewayFileSharesRequest &request)const;
void describeGatewayFileSharesAsync(const Model::DescribeGatewayFileSharesRequest& request, const DescribeGatewayFileSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayFileSharesOutcomeCallable describeGatewayFileSharesCallable(const Model::DescribeGatewayFileSharesRequest& request) const;
DescribeGatewayFileStatusOutcome describeGatewayFileStatus(const Model::DescribeGatewayFileStatusRequest &request)const;
void describeGatewayFileStatusAsync(const Model::DescribeGatewayFileStatusRequest& request, const DescribeGatewayFileStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayFileStatusOutcomeCallable describeGatewayFileStatusCallable(const Model::DescribeGatewayFileStatusRequest& request) const;
DescribeGatewayImagesOutcome describeGatewayImages(const Model::DescribeGatewayImagesRequest &request)const;
void describeGatewayImagesAsync(const Model::DescribeGatewayImagesRequest& request, const DescribeGatewayImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayImagesOutcomeCallable describeGatewayImagesCallable(const Model::DescribeGatewayImagesRequest& request) const;
DescribeGatewayInfoOutcome describeGatewayInfo(const Model::DescribeGatewayInfoRequest &request)const;
void describeGatewayInfoAsync(const Model::DescribeGatewayInfoRequest& request, const DescribeGatewayInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayInfoOutcomeCallable describeGatewayInfoCallable(const Model::DescribeGatewayInfoRequest& request) const;
DescribeGatewayLDAPInfoOutcome describeGatewayLDAPInfo(const Model::DescribeGatewayLDAPInfoRequest &request)const;
void describeGatewayLDAPInfoAsync(const Model::DescribeGatewayLDAPInfoRequest& request, const DescribeGatewayLDAPInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayLDAPInfoOutcomeCallable describeGatewayLDAPInfoCallable(const Model::DescribeGatewayLDAPInfoRequest& request) const;
DescribeGatewayLocationsOutcome describeGatewayLocations(const Model::DescribeGatewayLocationsRequest &request)const;
void describeGatewayLocationsAsync(const Model::DescribeGatewayLocationsRequest& request, const DescribeGatewayLocationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayLocationsOutcomeCallable describeGatewayLocationsCallable(const Model::DescribeGatewayLocationsRequest& request) const;
DescribeGatewayLoggingOutcome describeGatewayLogging(const Model::DescribeGatewayLoggingRequest &request)const;
void describeGatewayLoggingAsync(const Model::DescribeGatewayLoggingRequest& request, const DescribeGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayLoggingOutcomeCallable describeGatewayLoggingCallable(const Model::DescribeGatewayLoggingRequest& request) const;
DescribeGatewayLogsOutcome describeGatewayLogs(const Model::DescribeGatewayLogsRequest &request)const;
void describeGatewayLogsAsync(const Model::DescribeGatewayLogsRequest& request, const DescribeGatewayLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayLogsOutcomeCallable describeGatewayLogsCallable(const Model::DescribeGatewayLogsRequest& request) const;
DescribeGatewayModificationClassesOutcome describeGatewayModificationClasses(const Model::DescribeGatewayModificationClassesRequest &request)const;
void describeGatewayModificationClassesAsync(const Model::DescribeGatewayModificationClassesRequest& request, const DescribeGatewayModificationClassesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayModificationClassesOutcomeCallable describeGatewayModificationClassesCallable(const Model::DescribeGatewayModificationClassesRequest& request) const;
DescribeGatewaySMBUsersOutcome describeGatewaySMBUsers(const Model::DescribeGatewaySMBUsersRequest &request)const;
void describeGatewaySMBUsersAsync(const Model::DescribeGatewaySMBUsersRequest& request, const DescribeGatewaySMBUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewaySMBUsersOutcomeCallable describeGatewaySMBUsersCallable(const Model::DescribeGatewaySMBUsersRequest& request) const;
DescribeGatewayStatisticsOutcome describeGatewayStatistics(const Model::DescribeGatewayStatisticsRequest &request)const;
void describeGatewayStatisticsAsync(const Model::DescribeGatewayStatisticsRequest& request, const DescribeGatewayStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayStatisticsOutcomeCallable describeGatewayStatisticsCallable(const Model::DescribeGatewayStatisticsRequest& request) const;
DescribeGatewayStockOutcome describeGatewayStock(const Model::DescribeGatewayStockRequest &request)const;
void describeGatewayStockAsync(const Model::DescribeGatewayStockRequest& request, const DescribeGatewayStockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayStockOutcomeCallable describeGatewayStockCallable(const Model::DescribeGatewayStockRequest& request) const;
DescribeGatewayTypesOutcome describeGatewayTypes(const Model::DescribeGatewayTypesRequest &request)const;
void describeGatewayTypesAsync(const Model::DescribeGatewayTypesRequest& request, const DescribeGatewayTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewayTypesOutcomeCallable describeGatewayTypesCallable(const Model::DescribeGatewayTypesRequest& request) const;
DescribeGatewaysOutcome describeGateways(const Model::DescribeGatewaysRequest &request)const;
void describeGatewaysAsync(const Model::DescribeGatewaysRequest& request, const DescribeGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewaysOutcomeCallable describeGatewaysCallable(const Model::DescribeGatewaysRequest& request) const;
DescribeGatewaysForCmsOutcome describeGatewaysForCms(const Model::DescribeGatewaysForCmsRequest &request)const;
void describeGatewaysForCmsAsync(const Model::DescribeGatewaysForCmsRequest& request, const DescribeGatewaysForCmsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewaysForCmsOutcomeCallable describeGatewaysForCmsCallable(const Model::DescribeGatewaysForCmsRequest& request) const;
DescribeGatewaysTagsOutcome describeGatewaysTags(const Model::DescribeGatewaysTagsRequest &request)const;
void describeGatewaysTagsAsync(const Model::DescribeGatewaysTagsRequest& request, const DescribeGatewaysTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGatewaysTagsOutcomeCallable describeGatewaysTagsCallable(const Model::DescribeGatewaysTagsRequest& request) const;
DescribeKmsKeyOutcome describeKmsKey(const Model::DescribeKmsKeyRequest &request)const;
void describeKmsKeyAsync(const Model::DescribeKmsKeyRequest& request, const DescribeKmsKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeKmsKeyOutcomeCallable describeKmsKeyCallable(const Model::DescribeKmsKeyRequest& request) const;
DescribeMqttConfigOutcome describeMqttConfig(const Model::DescribeMqttConfigRequest &request)const;
void describeMqttConfigAsync(const Model::DescribeMqttConfigRequest& request, const DescribeMqttConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMqttConfigOutcomeCallable describeMqttConfigCallable(const Model::DescribeMqttConfigRequest& request) const;
DescribeOssBucketInfoOutcome describeOssBucketInfo(const Model::DescribeOssBucketInfoRequest &request)const;
void describeOssBucketInfoAsync(const Model::DescribeOssBucketInfoRequest& request, const DescribeOssBucketInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeOssBucketInfoOutcomeCallable describeOssBucketInfoCallable(const Model::DescribeOssBucketInfoRequest& request) const;
DescribeOssBucketsOutcome describeOssBuckets(const Model::DescribeOssBucketsRequest &request)const;
void describeOssBucketsAsync(const Model::DescribeOssBucketsRequest& request, const DescribeOssBucketsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeOssBucketsOutcomeCallable describeOssBucketsCallable(const Model::DescribeOssBucketsRequest& request) const;
DescribePayAsYouGoPriceOutcome describePayAsYouGoPrice(const Model::DescribePayAsYouGoPriceRequest &request)const;
void describePayAsYouGoPriceAsync(const Model::DescribePayAsYouGoPriceRequest& request, const DescribePayAsYouGoPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePayAsYouGoPriceOutcomeCallable describePayAsYouGoPriceCallable(const Model::DescribePayAsYouGoPriceRequest& 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;
DescribeSharesBucketInfoForExpressSyncOutcome describeSharesBucketInfoForExpressSync(const Model::DescribeSharesBucketInfoForExpressSyncRequest &request)const;
void describeSharesBucketInfoForExpressSyncAsync(const Model::DescribeSharesBucketInfoForExpressSyncRequest& request, const DescribeSharesBucketInfoForExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSharesBucketInfoForExpressSyncOutcomeCallable describeSharesBucketInfoForExpressSyncCallable(const Model::DescribeSharesBucketInfoForExpressSyncRequest& request) const;
DescribeStorageBundleOutcome describeStorageBundle(const Model::DescribeStorageBundleRequest &request)const;
void describeStorageBundleAsync(const Model::DescribeStorageBundleRequest& request, const DescribeStorageBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeStorageBundleOutcomeCallable describeStorageBundleCallable(const Model::DescribeStorageBundleRequest& request) const;
DescribeStorageBundlesOutcome describeStorageBundles(const Model::DescribeStorageBundlesRequest &request)const;
void describeStorageBundlesAsync(const Model::DescribeStorageBundlesRequest& request, const DescribeStorageBundlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeStorageBundlesOutcomeCallable describeStorageBundlesCallable(const Model::DescribeStorageBundlesRequest& request) const;
DescribeSubscriptionPriceOutcome describeSubscriptionPrice(const Model::DescribeSubscriptionPriceRequest &request)const;
void describeSubscriptionPriceAsync(const Model::DescribeSubscriptionPriceRequest& request, const DescribeSubscriptionPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSubscriptionPriceOutcomeCallable describeSubscriptionPriceCallable(const Model::DescribeSubscriptionPriceRequest& request) const;
DescribeTasksOutcome describeTasks(const Model::DescribeTasksRequest &request)const;
void describeTasksAsync(const Model::DescribeTasksRequest& request, const DescribeTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTasksOutcomeCallable describeTasksCallable(const Model::DescribeTasksRequest& request) const;
DescribeUserBusinessStatusOutcome describeUserBusinessStatus(const Model::DescribeUserBusinessStatusRequest &request)const;
void describeUserBusinessStatusAsync(const Model::DescribeUserBusinessStatusRequest& request, const DescribeUserBusinessStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeUserBusinessStatusOutcomeCallable describeUserBusinessStatusCallable(const Model::DescribeUserBusinessStatusRequest& request) const;
DescribeVSwitchesOutcome describeVSwitches(const Model::DescribeVSwitchesRequest &request)const;
void describeVSwitchesAsync(const Model::DescribeVSwitchesRequest& request, const DescribeVSwitchesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVSwitchesOutcomeCallable describeVSwitchesCallable(const Model::DescribeVSwitchesRequest& request) const;
DescribeVpcsOutcome describeVpcs(const Model::DescribeVpcsRequest &request)const;
void describeVpcsAsync(const Model::DescribeVpcsRequest& request, const DescribeVpcsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVpcsOutcomeCallable describeVpcsCallable(const Model::DescribeVpcsRequest& request) const;
DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const;
void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const;
DisableGatewayLoggingOutcome disableGatewayLogging(const Model::DisableGatewayLoggingRequest &request)const;
void disableGatewayLoggingAsync(const Model::DisableGatewayLoggingRequest& request, const DisableGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableGatewayLoggingOutcomeCallable disableGatewayLoggingCallable(const Model::DisableGatewayLoggingRequest& request) const;
EnableGatewayLoggingOutcome enableGatewayLogging(const Model::EnableGatewayLoggingRequest &request)const;
void enableGatewayLoggingAsync(const Model::EnableGatewayLoggingRequest& request, const EnableGatewayLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableGatewayLoggingOutcomeCallable enableGatewayLoggingCallable(const Model::EnableGatewayLoggingRequest& request) const;
ExpandCacheDiskOutcome expandCacheDisk(const Model::ExpandCacheDiskRequest &request)const;
void expandCacheDiskAsync(const Model::ExpandCacheDiskRequest& request, const ExpandCacheDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExpandCacheDiskOutcomeCallable expandCacheDiskCallable(const Model::ExpandCacheDiskRequest& request) const;
ExpandGatewayNetworkBandwidthOutcome expandGatewayNetworkBandwidth(const Model::ExpandGatewayNetworkBandwidthRequest &request)const;
void expandGatewayNetworkBandwidthAsync(const Model::ExpandGatewayNetworkBandwidthRequest& request, const ExpandGatewayNetworkBandwidthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExpandGatewayNetworkBandwidthOutcomeCallable expandGatewayNetworkBandwidthCallable(const Model::ExpandGatewayNetworkBandwidthRequest& request) const;
GenerateGatewayTokenOutcome generateGatewayToken(const Model::GenerateGatewayTokenRequest &request)const;
void generateGatewayTokenAsync(const Model::GenerateGatewayTokenRequest& request, const GenerateGatewayTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateGatewayTokenOutcomeCallable generateGatewayTokenCallable(const Model::GenerateGatewayTokenRequest& request) const;
GenerateMqttTokenOutcome generateMqttToken(const Model::GenerateMqttTokenRequest &request)const;
void generateMqttTokenAsync(const Model::GenerateMqttTokenRequest& request, const GenerateMqttTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateMqttTokenOutcomeCallable generateMqttTokenCallable(const Model::GenerateMqttTokenRequest& request) const;
GenerateStsTokenOutcome generateStsToken(const Model::GenerateStsTokenRequest &request)const;
void generateStsTokenAsync(const Model::GenerateStsTokenRequest& request, const GenerateStsTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateStsTokenOutcomeCallable generateStsTokenCallable(const Model::GenerateStsTokenRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
ModifyGatewayOutcome modifyGateway(const Model::ModifyGatewayRequest &request)const;
void modifyGatewayAsync(const Model::ModifyGatewayRequest& request, const ModifyGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyGatewayOutcomeCallable modifyGatewayCallable(const Model::ModifyGatewayRequest& request) const;
ModifyGatewayBlockVolumeOutcome modifyGatewayBlockVolume(const Model::ModifyGatewayBlockVolumeRequest &request)const;
void modifyGatewayBlockVolumeAsync(const Model::ModifyGatewayBlockVolumeRequest& request, const ModifyGatewayBlockVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyGatewayBlockVolumeOutcomeCallable modifyGatewayBlockVolumeCallable(const Model::ModifyGatewayBlockVolumeRequest& request) const;
ModifyGatewayClassOutcome modifyGatewayClass(const Model::ModifyGatewayClassRequest &request)const;
void modifyGatewayClassAsync(const Model::ModifyGatewayClassRequest& request, const ModifyGatewayClassAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyGatewayClassOutcomeCallable modifyGatewayClassCallable(const Model::ModifyGatewayClassRequest& request) const;
ModifyGatewayFileShareOutcome modifyGatewayFileShare(const Model::ModifyGatewayFileShareRequest &request)const;
void modifyGatewayFileShareAsync(const Model::ModifyGatewayFileShareRequest& request, const ModifyGatewayFileShareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyGatewayFileShareOutcomeCallable modifyGatewayFileShareCallable(const Model::ModifyGatewayFileShareRequest& request) const;
ModifyStorageBundleOutcome modifyStorageBundle(const Model::ModifyStorageBundleRequest &request)const;
void modifyStorageBundleAsync(const Model::ModifyStorageBundleRequest& request, const ModifyStorageBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyStorageBundleOutcomeCallable modifyStorageBundleCallable(const Model::ModifyStorageBundleRequest& request) const;
OperateGatewayOutcome operateGateway(const Model::OperateGatewayRequest &request)const;
void operateGatewayAsync(const Model::OperateGatewayRequest& request, const OperateGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
OperateGatewayOutcomeCallable operateGatewayCallable(const Model::OperateGatewayRequest& request) const;
ReleaseServiceOutcome releaseService(const Model::ReleaseServiceRequest &request)const;
void releaseServiceAsync(const Model::ReleaseServiceRequest& request, const ReleaseServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReleaseServiceOutcomeCallable releaseServiceCallable(const Model::ReleaseServiceRequest& request) const;
RemoveSharesFromExpressSyncOutcome removeSharesFromExpressSync(const Model::RemoveSharesFromExpressSyncRequest &request)const;
void removeSharesFromExpressSyncAsync(const Model::RemoveSharesFromExpressSyncRequest& request, const RemoveSharesFromExpressSyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveSharesFromExpressSyncOutcomeCallable removeSharesFromExpressSyncCallable(const Model::RemoveSharesFromExpressSyncRequest& request) const;
RemoveTagsFromGatewayOutcome removeTagsFromGateway(const Model::RemoveTagsFromGatewayRequest &request)const;
void removeTagsFromGatewayAsync(const Model::RemoveTagsFromGatewayRequest& request, const RemoveTagsFromGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveTagsFromGatewayOutcomeCallable removeTagsFromGatewayCallable(const Model::RemoveTagsFromGatewayRequest& request) const;
ReportBlockVolumesOutcome reportBlockVolumes(const Model::ReportBlockVolumesRequest &request)const;
void reportBlockVolumesAsync(const Model::ReportBlockVolumesRequest& request, const ReportBlockVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReportBlockVolumesOutcomeCallable reportBlockVolumesCallable(const Model::ReportBlockVolumesRequest& request) const;
ReportFileSharesOutcome reportFileShares(const Model::ReportFileSharesRequest &request)const;
void reportFileSharesAsync(const Model::ReportFileSharesRequest& request, const ReportFileSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReportFileSharesOutcomeCallable reportFileSharesCallable(const Model::ReportFileSharesRequest& request) const;
ReportGatewayInfoOutcome reportGatewayInfo(const Model::ReportGatewayInfoRequest &request)const;
void reportGatewayInfoAsync(const Model::ReportGatewayInfoRequest& request, const ReportGatewayInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReportGatewayInfoOutcomeCallable reportGatewayInfoCallable(const Model::ReportGatewayInfoRequest& request) const;
ReportGatewayUsageOutcome reportGatewayUsage(const Model::ReportGatewayUsageRequest &request)const;
void reportGatewayUsageAsync(const Model::ReportGatewayUsageRequest& request, const ReportGatewayUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReportGatewayUsageOutcomeCallable reportGatewayUsageCallable(const Model::ReportGatewayUsageRequest& request) const;
ResetGatewayPasswordOutcome resetGatewayPassword(const Model::ResetGatewayPasswordRequest &request)const;
void resetGatewayPasswordAsync(const Model::ResetGatewayPasswordRequest& request, const ResetGatewayPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ResetGatewayPasswordOutcomeCallable resetGatewayPasswordCallable(const Model::ResetGatewayPasswordRequest& request) const;
RestartFileSharesOutcome restartFileShares(const Model::RestartFileSharesRequest &request)const;
void restartFileSharesAsync(const Model::RestartFileSharesRequest& request, const RestartFileSharesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestartFileSharesOutcomeCallable restartFileSharesCallable(const Model::RestartFileSharesRequest& request) const;
SetGatewayADInfoOutcome setGatewayADInfo(const Model::SetGatewayADInfoRequest &request)const;
void setGatewayADInfoAsync(const Model::SetGatewayADInfoRequest& request, const SetGatewayADInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetGatewayADInfoOutcomeCallable setGatewayADInfoCallable(const Model::SetGatewayADInfoRequest& request) const;
SetGatewayDNSOutcome setGatewayDNS(const Model::SetGatewayDNSRequest &request)const;
void setGatewayDNSAsync(const Model::SetGatewayDNSRequest& request, const SetGatewayDNSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetGatewayDNSOutcomeCallable setGatewayDNSCallable(const Model::SetGatewayDNSRequest& request) const;
SetGatewayLDAPInfoOutcome setGatewayLDAPInfo(const Model::SetGatewayLDAPInfoRequest &request)const;
void setGatewayLDAPInfoAsync(const Model::SetGatewayLDAPInfoRequest& request, const SetGatewayLDAPInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetGatewayLDAPInfoOutcomeCallable setGatewayLDAPInfoCallable(const Model::SetGatewayLDAPInfoRequest& request) const;
SwitchGatewayExpirationPolicyOutcome switchGatewayExpirationPolicy(const Model::SwitchGatewayExpirationPolicyRequest &request)const;
void switchGatewayExpirationPolicyAsync(const Model::SwitchGatewayExpirationPolicyRequest& request, const SwitchGatewayExpirationPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SwitchGatewayExpirationPolicyOutcomeCallable switchGatewayExpirationPolicyCallable(const Model::SwitchGatewayExpirationPolicyRequest& request) const;
SwitchToSubscriptionOutcome switchToSubscription(const Model::SwitchToSubscriptionRequest &request)const;
void switchToSubscriptionAsync(const Model::SwitchToSubscriptionRequest& request, const SwitchToSubscriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SwitchToSubscriptionOutcomeCallable switchToSubscriptionCallable(const Model::SwitchToSubscriptionRequest& request) const;
TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;
UpdateGatewayBlockVolumeOutcome updateGatewayBlockVolume(const Model::UpdateGatewayBlockVolumeRequest &request)const;
void updateGatewayBlockVolumeAsync(const Model::UpdateGatewayBlockVolumeRequest& request, const UpdateGatewayBlockVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateGatewayBlockVolumeOutcomeCallable updateGatewayBlockVolumeCallable(const Model::UpdateGatewayBlockVolumeRequest& request) const;
UpdateGatewayFileShareOutcome updateGatewayFileShare(const Model::UpdateGatewayFileShareRequest &request)const;
void updateGatewayFileShareAsync(const Model::UpdateGatewayFileShareRequest& request, const UpdateGatewayFileShareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateGatewayFileShareOutcomeCallable updateGatewayFileShareCallable(const Model::UpdateGatewayFileShareRequest& request) const;
UpgradeGatewayOutcome upgradeGateway(const Model::UpgradeGatewayRequest &request)const;
void upgradeGatewayAsync(const Model::UpgradeGatewayRequest& request, const UpgradeGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpgradeGatewayOutcomeCallable upgradeGatewayCallable(const Model::UpgradeGatewayRequest& request) const;
UploadGatewayLogOutcome uploadGatewayLog(const Model::UploadGatewayLogRequest &request)const;
void uploadGatewayLogAsync(const Model::UploadGatewayLogRequest& request, const UploadGatewayLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UploadGatewayLogOutcomeCallable uploadGatewayLogCallable(const Model::UploadGatewayLogRequest& request) const;
ValidateExpressSyncConfigOutcome validateExpressSyncConfig(const Model::ValidateExpressSyncConfigRequest &request)const;
void validateExpressSyncConfigAsync(const Model::ValidateExpressSyncConfigRequest& request, const ValidateExpressSyncConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ValidateExpressSyncConfigOutcomeCallable validateExpressSyncConfigCallable(const Model::ValidateExpressSyncConfigRequest& request) const;
ValidateGatewayNameOutcome validateGatewayName(const Model::ValidateGatewayNameRequest &request)const;
void validateGatewayNameAsync(const Model::ValidateGatewayNameRequest& request, const ValidateGatewayNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ValidateGatewayNameOutcomeCallable validateGatewayNameCallable(const Model::ValidateGatewayNameRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_SGW_SGWCLIENT_H_

32
sgw/include/alibabacloud/sgw/SgwExport.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_SGW_SGWEXPORT_H_
#define ALIBABACLOUD_SGW_SGWEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_SGW_LIBRARY)
# define ALIBABACLOUD_SGW_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_SGW_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_SGW_EXPORT
#endif
#endif // !ALIBABACLOUD_SGW_SGWEXPORT_H_

66
sgw/include/alibabacloud/sgw/model/ActivateAllInOneGatewayRequest.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_SGW_MODEL_ACTIVATEALLINONEGATEWAYREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_ACTIVATEALLINONEGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT ActivateAllInOneGatewayRequest : public RpcServiceRequest
{
public:
ActivateAllInOneGatewayRequest();
~ActivateAllInOneGatewayRequest();
std::string getClientUUID()const;
void setClientUUID(const std::string& clientUUID);
std::string getSerialNumber()const;
void setSerialNumber(const std::string& serialNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getDeviceNumber()const;
void setDeviceNumber(const std::string& deviceNumber);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getModel()const;
void setModel(const std::string& model);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string clientUUID_;
std::string serialNumber_;
std::string accessKeyId_;
std::string deviceNumber_;
std::string securityToken_;
std::string model_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_ACTIVATEALLINONEGATEWAYREQUEST_H_

61
sgw/include/alibabacloud/sgw/model/ActivateAllInOneGatewayResult.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_SGW_MODEL_ACTIVATEALLINONEGATEWAYRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_ACTIVATEALLINONEGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT ActivateAllInOneGatewayResult : public ServiceResult
{
public:
ActivateAllInOneGatewayResult();
explicit ActivateAllInOneGatewayResult(const std::string &payload);
~ActivateAllInOneGatewayResult();
std::string getMessage()const;
std::string getRegionId()const;
std::string getGatewayId()const;
std::string getCode()const;
std::string getLicenseContent()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string regionId_;
std::string gatewayId_;
std::string code_;
std::string licenseContent_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_ACTIVATEALLINONEGATEWAYRESULT_H_

69
sgw/include/alibabacloud/sgw/model/ActivateGatewayRequest.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_SGW_MODEL_ACTIVATEGATEWAYREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT ActivateGatewayRequest : public RpcServiceRequest
{
public:
ActivateGatewayRequest();
~ActivateGatewayRequest();
std::string getClientUUID()const;
void setClientUUID(const std::string& clientUUID);
std::string getSerialNumber()const;
void setSerialNumber(const std::string& serialNumber);
std::string getType()const;
void setType(const std::string& type);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getToken()const;
void setToken(const std::string& token);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getModel()const;
void setModel(const std::string& model);
std::string getCategory()const;
void setCategory(const std::string& category);
private:
std::string clientUUID_;
std::string serialNumber_;
std::string type_;
std::string accessKeyId_;
std::string token_;
std::string securityToken_;
std::string model_;
std::string category_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYREQUEST_H_

59
sgw/include/alibabacloud/sgw/model/ActivateGatewayResult.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_SGW_MODEL_ACTIVATEGATEWAYRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT ActivateGatewayResult : public ServiceResult
{
public:
ActivateGatewayResult();
explicit ActivateGatewayResult(const std::string &payload);
~ActivateGatewayResult();
std::string getMessage()const;
std::string getRegionId()const;
std::string getGatewayId()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string regionId_;
std::string gatewayId_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_ACTIVATEGATEWAYRESULT_H_

60
sgw/include/alibabacloud/sgw/model/AddSharesToExpressSyncRequest.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_SGW_MODEL_ADDSHARESTOEXPRESSSYNCREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_ADDSHARESTOEXPRESSSYNCREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT AddSharesToExpressSyncRequest : public RpcServiceRequest
{
public:
AddSharesToExpressSyncRequest();
~AddSharesToExpressSyncRequest();
std::string getExpressSyncId()const;
void setExpressSyncId(const std::string& expressSyncId);
std::string getGatewayShares()const;
void setGatewayShares(const std::string& gatewayShares);
std::string getGatewayRegions()const;
void setGatewayRegions(const std::string& gatewayRegions);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
private:
std::string expressSyncId_;
std::string gatewayShares_;
std::string gatewayRegions_;
std::string accessKeyId_;
std::string securityToken_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_ADDSHARESTOEXPRESSSYNCREQUEST_H_

67
sgw/include/alibabacloud/sgw/model/AddSharesToExpressSyncResult.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_SGW_MODEL_ADDSHARESTOEXPRESSSYNCRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_ADDSHARESTOEXPRESSSYNCRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT AddSharesToExpressSyncResult : public ServiceResult
{
public:
AddSharesToExpressSyncResult();
explicit AddSharesToExpressSyncResult(const std::string &payload);
~AddSharesToExpressSyncResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getMnsTopic()const;
std::string getMnsQueues()const;
long getMnsFullSyncDelay()const;
std::string getMnsPublicEndpoint()const;
std::string getCode()const;
std::string getMnsInnerEndpoint()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string mnsTopic_;
std::string mnsQueues_;
long mnsFullSyncDelay_;
std::string mnsPublicEndpoint_;
std::string code_;
std::string mnsInnerEndpoint_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_ADDSHARESTOEXPRESSSYNCRESULT_H_

57
sgw/include/alibabacloud/sgw/model/AddTagsToGatewayRequest.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_SGW_MODEL_ADDTAGSTOGATEWAYREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_ADDTAGSTOGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT AddTagsToGatewayRequest : public RpcServiceRequest
{
public:
AddTagsToGatewayRequest();
~AddTagsToGatewayRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string tags_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_ADDTAGSTOGATEWAYREQUEST_H_

55
sgw/include/alibabacloud/sgw/model/AddTagsToGatewayResult.h Normal file
View File

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

63
sgw/include/alibabacloud/sgw/model/CheckActivationKeyRequest.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_SGW_MODEL_CHECKACTIVATIONKEYREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKACTIVATIONKEYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckActivationKeyRequest : public RpcServiceRequest
{
public:
CheckActivationKeyRequest();
~CheckActivationKeyRequest();
std::string getCryptKey()const;
void setCryptKey(const std::string& cryptKey);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getToken()const;
void setToken(const std::string& token);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getCryptText()const;
void setCryptText(const std::string& cryptText);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string cryptKey_;
std::string accessKeyId_;
std::string token_;
std::string securityToken_;
std::string cryptText_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKACTIVATIONKEYREQUEST_H_

55
sgw/include/alibabacloud/sgw/model/CheckActivationKeyResult.h Normal file
View File

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

60
sgw/include/alibabacloud/sgw/model/CheckBlockVolumeNameRequest.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_SGW_MODEL_CHECKBLOCKVOLUMENAMEREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKBLOCKVOLUMENAMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckBlockVolumeNameRequest : public RpcServiceRequest
{
public:
CheckBlockVolumeNameRequest();
~CheckBlockVolumeNameRequest();
std::string getVolumeName()const;
void setVolumeName(const std::string& volumeName);
std::string getBucketEndpoint()const;
void setBucketEndpoint(const std::string& bucketEndpoint);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getBucketName()const;
void setBucketName(const std::string& bucketName);
private:
std::string volumeName_;
std::string bucketEndpoint_;
std::string accessKeyId_;
std::string securityToken_;
std::string bucketName_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKBLOCKVOLUMENAMEREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/CheckBlockVolumeNameResult.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_SGW_MODEL_CHECKBLOCKVOLUMENAMERESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKBLOCKVOLUMENAMERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckBlockVolumeNameResult : public ServiceResult
{
public:
CheckBlockVolumeNameResult();
explicit CheckBlockVolumeNameResult(const std::string &payload);
~CheckBlockVolumeNameResult();
std::string getIsRequireRecovery()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string isRequireRecovery_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKBLOCKVOLUMENAMERESULT_H_

54
sgw/include/alibabacloud/sgw/model/CheckGatewayEssdSupportRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_CHECKGATEWAYESSDSUPPORTREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKGATEWAYESSDSUPPORTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckGatewayEssdSupportRequest : public RpcServiceRequest
{
public:
CheckGatewayEssdSupportRequest();
~CheckGatewayEssdSupportRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKGATEWAYESSDSUPPORTREQUEST_H_

59
sgw/include/alibabacloud/sgw/model/CheckGatewayEssdSupportResult.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_SGW_MODEL_CHECKGATEWAYESSDSUPPORTRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKGATEWAYESSDSUPPORTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckGatewayEssdSupportResult : public ServiceResult
{
public:
CheckGatewayEssdSupportResult();
explicit CheckGatewayEssdSupportResult(const std::string &payload);
~CheckGatewayEssdSupportResult();
bool getIsSupportEssd()const;
std::string getMessage()const;
bool getIsServiceAffect()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool isSupportEssd_;
std::string message_;
bool isServiceAffect_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKGATEWAYESSDSUPPORTRESULT_H_

51
sgw/include/alibabacloud/sgw/model/CheckMnsServiceRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICEREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckMnsServiceRequest : public RpcServiceRequest
{
public:
CheckMnsServiceRequest();
~CheckMnsServiceRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
private:
std::string accessKeyId_;
std::string securityToken_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICEREQUEST_H_

59
sgw/include/alibabacloud/sgw/model/CheckMnsServiceResult.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_SGW_MODEL_CHECKMNSSERVICERESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckMnsServiceResult : public ServiceResult
{
public:
CheckMnsServiceResult();
explicit CheckMnsServiceResult(const std::string &payload);
~CheckMnsServiceResult();
std::string getMessage()const;
bool getIsEnabled()const;
std::string getCheckMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
bool isEnabled_;
std::string checkMessage_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKMNSSERVICERESULT_H_

54
sgw/include/alibabacloud/sgw/model/CheckRoleRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_CHECKROLEREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKROLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckRoleRequest : public RpcServiceRequest
{
public:
CheckRoleRequest();
~CheckRoleRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRoleType()const;
void setRoleType(const std::string& roleType);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string roleType_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKROLEREQUEST_H_

55
sgw/include/alibabacloud/sgw/model/CheckRoleResult.h Normal file
View File

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

57
sgw/include/alibabacloud/sgw/model/CheckSlrRoleRequest.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_SGW_MODEL_CHECKSLRROLEREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKSLRROLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckSlrRoleRequest : public RpcServiceRequest
{
public:
CheckSlrRoleRequest();
~CheckSlrRoleRequest();
std::string getRoleName()const;
void setRoleName(const std::string& roleName);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
bool getCreateIfNotExist()const;
void setCreateIfNotExist(bool createIfNotExist);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
private:
std::string roleName_;
std::string accessKeyId_;
bool createIfNotExist_;
std::string securityToken_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKSLRROLEREQUEST_H_

59
sgw/include/alibabacloud/sgw/model/CheckSlrRoleResult.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_SGW_MODEL_CHECKSLRROLERESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKSLRROLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckSlrRoleResult : public ServiceResult
{
public:
CheckSlrRoleResult();
explicit CheckSlrRoleResult(const std::string &payload);
~CheckSlrRoleResult();
bool getExist()const;
bool getRequireOldWayCheck()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool exist_;
bool requireOldWayCheck_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKSLRROLERESULT_H_

60
sgw/include/alibabacloud/sgw/model/CheckUpgradeVersionRequest.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_SGW_MODEL_CHECKUPGRADEVERSIONREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKUPGRADEVERSIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckUpgradeVersionRequest : public RpcServiceRequest
{
public:
CheckUpgradeVersionRequest();
~CheckUpgradeVersionRequest();
std::string getClientUUID()const;
void setClientUUID(const std::string& clientUUID);
std::string getGatewayVersion()const;
void setGatewayVersion(const std::string& gatewayVersion);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string clientUUID_;
std::string gatewayVersion_;
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKUPGRADEVERSIONREQUEST_H_

68
sgw/include/alibabacloud/sgw/model/CheckUpgradeVersionResult.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_SGW_MODEL_CHECKUPGRADEVERSIONRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CHECKUPGRADEVERSIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CheckUpgradeVersionResult : public ServiceResult
{
public:
struct Patch
{
std::string internalUrl;
std::string url;
std::string name;
std::string mD5;
};
CheckUpgradeVersionResult();
explicit CheckUpgradeVersionResult(const std::string &payload);
~CheckUpgradeVersionResult();
std::string getMessage()const;
std::string getLatestVersion()const;
std::string getOption()const;
std::string getCode()const;
bool getSuccess()const;
std::vector<Patch> getPatches()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string latestVersion_;
std::string option_;
std::string code_;
bool success_;
std::vector<Patch> patches_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CHECKUPGRADEVERSIONRESULT_H_

60
sgw/include/alibabacloud/sgw/model/CreateCacheRequest.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_SGW_MODEL_CREATECACHEREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CREATECACHEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateCacheRequest : public RpcServiceRequest
{
public:
CreateCacheRequest();
~CreateCacheRequest();
long getSizeInGB()const;
void setSizeInGB(long sizeInGB);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getCategory()const;
void setCategory(const std::string& category);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
long sizeInGB_;
std::string accessKeyId_;
std::string securityToken_;
std::string category_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATECACHEREQUEST_H_

59
sgw/include/alibabacloud/sgw/model/CreateCacheResult.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_SGW_MODEL_CREATECACHERESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CREATECACHERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateCacheResult : public ServiceResult
{
public:
CreateCacheResult();
explicit CreateCacheResult(const std::string &payload);
~CreateCacheResult();
std::string getBuyURL()const;
std::string getMessage()const;
std::string getCacheId()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string buyURL_;
std::string message_;
std::string cacheId_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATECACHERESULT_H_

66
sgw/include/alibabacloud/sgw/model/CreateExpressSyncRequest.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_SGW_MODEL_CREATEEXPRESSSYNCREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEEXPRESSSYNCREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateExpressSyncRequest : public RpcServiceRequest
{
public:
CreateExpressSyncRequest();
~CreateExpressSyncRequest();
std::string getBucketRegion()const;
void setBucketRegion(const std::string& bucketRegion);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getBucketName()const;
void setBucketName(const std::string& bucketName);
std::string getName()const;
void setName(const std::string& name);
std::string getBucketPrefix()const;
void setBucketPrefix(const std::string& bucketPrefix);
private:
std::string bucketRegion_;
std::string description_;
std::string accessKeyId_;
std::string securityToken_;
std::string bucketName_;
std::string name_;
std::string bucketPrefix_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEEXPRESSSYNCREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/CreateExpressSyncResult.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_SGW_MODEL_CREATEEXPRESSSYNCRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEEXPRESSSYNCRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateExpressSyncResult : public ServiceResult
{
public:
CreateExpressSyncResult();
explicit CreateExpressSyncResult(const std::string &payload);
~CreateExpressSyncResult();
std::string getMessage()const;
std::string getCode()const;
std::string getExpressSyncId()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string code_;
std::string expressSyncId_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEEXPRESSSYNCRESULT_H_

93
sgw/include/alibabacloud/sgw/model/CreateGatewayBlockVolumeRequest.h Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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_SGW_MODEL_CREATEGATEWAYBLOCKVOLUMEREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYBLOCKVOLUMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewayBlockVolumeRequest : public RpcServiceRequest
{
public:
CreateGatewayBlockVolumeRequest();
~CreateGatewayBlockVolumeRequest();
std::string getOssEndpoint()const;
void setOssEndpoint(const std::string& ossEndpoint);
bool getRecovery()const;
void setRecovery(bool recovery);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
int getChunkSize()const;
void setChunkSize(int chunkSize);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
std::string getVolumeProtocol()const;
void setVolumeProtocol(const std::string& volumeProtocol);
bool getChapEnabled()const;
void setChapEnabled(bool chapEnabled);
std::string getCacheMode()const;
void setCacheMode(const std::string& cacheMode);
std::string getLocalFilePath()const;
void setLocalFilePath(const std::string& localFilePath);
bool getOssBucketSsl()const;
void setOssBucketSsl(bool ossBucketSsl);
long getSize()const;
void setSize(long size);
std::string getChapInUser()const;
void setChapInUser(const std::string& chapInUser);
std::string getName()const;
void setName(const std::string& name);
std::string getOssBucketName()const;
void setOssBucketName(const std::string& ossBucketName);
std::string getChapInPassword()const;
void setChapInPassword(const std::string& chapInPassword);
private:
std::string ossEndpoint_;
bool recovery_;
std::string accessKeyId_;
std::string securityToken_;
int chunkSize_;
std::string gatewayId_;
std::string volumeProtocol_;
bool chapEnabled_;
std::string cacheMode_;
std::string localFilePath_;
bool ossBucketSsl_;
long size_;
std::string chapInUser_;
std::string name_;
std::string ossBucketName_;
std::string chapInPassword_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYBLOCKVOLUMEREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/CreateGatewayBlockVolumeResult.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_SGW_MODEL_CREATEGATEWAYBLOCKVOLUMERESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYBLOCKVOLUMERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewayBlockVolumeResult : public ServiceResult
{
public:
CreateGatewayBlockVolumeResult();
explicit CreateGatewayBlockVolumeResult(const std::string &payload);
~CreateGatewayBlockVolumeResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYBLOCKVOLUMERESULT_H_

60
sgw/include/alibabacloud/sgw/model/CreateGatewayCacheDiskRequest.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_SGW_MODEL_CREATEGATEWAYCACHEDISKREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYCACHEDISKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewayCacheDiskRequest : public RpcServiceRequest
{
public:
CreateGatewayCacheDiskRequest();
~CreateGatewayCacheDiskRequest();
long getCacheDiskSizeInGB()const;
void setCacheDiskSizeInGB(long cacheDiskSizeInGB);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getCacheDiskCategory()const;
void setCacheDiskCategory(const std::string& cacheDiskCategory);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
long cacheDiskSizeInGB_;
std::string accessKeyId_;
std::string securityToken_;
std::string cacheDiskCategory_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYCACHEDISKREQUEST_H_

59
sgw/include/alibabacloud/sgw/model/CreateGatewayCacheDiskResult.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_SGW_MODEL_CREATEGATEWAYCACHEDISKRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYCACHEDISKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewayCacheDiskResult : public ServiceResult
{
public:
CreateGatewayCacheDiskResult();
explicit CreateGatewayCacheDiskResult(const std::string &payload);
~CreateGatewayCacheDiskResult();
std::string getBuyURL()const;
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string buyURL_;
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYCACHEDISKRESULT_H_

165
sgw/include/alibabacloud/sgw/model/CreateGatewayFileShareRequest.h Normal file
View File

@@ -0,0 +1,165 @@
/*
* 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_SGW_MODEL_CREATEGATEWAYFILESHAREREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYFILESHAREREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewayFileShareRequest : public RpcServiceRequest
{
public:
CreateGatewayFileShareRequest();
~CreateGatewayFileShareRequest();
bool getInPlace()const;
void setInPlace(bool inPlace);
std::string getOssEndpoint()const;
void setOssEndpoint(const std::string& ossEndpoint);
std::string getReadWriteClientList()const;
void setReadWriteClientList(const std::string& readWriteClientList);
int getBackendLimit()const;
void setBackendLimit(int backendLimit);
std::string getSquash()const;
void setSquash(const std::string& squash);
std::string getReadOnlyClientList()const;
void setReadOnlyClientList(const std::string& readOnlyClientList);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
long getKmsRotatePeriod()const;
void setKmsRotatePeriod(long kmsRotatePeriod);
bool getRemoteSyncDownload()const;
void setRemoteSyncDownload(bool remoteSyncDownload);
std::string getShareProtocol()const;
void setShareProtocol(const std::string& shareProtocol);
bool getNfsV4Optimization()const;
void setNfsV4Optimization(bool nfsV4Optimization);
bool getAccessBasedEnumeration()const;
void setAccessBasedEnumeration(bool accessBasedEnumeration);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
bool getSupportArchive()const;
void setSupportArchive(bool supportArchive);
std::string getCacheMode()const;
void setCacheMode(const std::string& cacheMode);
std::string getLocalFilePath()const;
void setLocalFilePath(const std::string& localFilePath);
std::string getPartialSyncPaths()const;
void setPartialSyncPaths(const std::string& partialSyncPaths);
int getDownloadLimit()const;
void setDownloadLimit(int downloadLimit);
std::string getReadOnlyUserList()const;
void setReadOnlyUserList(const std::string& readOnlyUserList);
bool getFastReclaim()const;
void setFastReclaim(bool fastReclaim);
bool getWindowsAcl()const;
void setWindowsAcl(bool windowsAcl);
std::string getName()const;
void setName(const std::string& name);
std::string getOssBucketName()const;
void setOssBucketName(const std::string& ossBucketName);
bool getTransferAcceleration()const;
void setTransferAcceleration(bool transferAcceleration);
std::string getClientSideCmk()const;
void setClientSideCmk(const std::string& clientSideCmk);
std::string getPathPrefix()const;
void setPathPrefix(const std::string& pathPrefix);
bool getBrowsable()const;
void setBrowsable(bool browsable);
std::string getReadWriteUserList()const;
void setReadWriteUserList(const std::string& readWriteUserList);
int getPollingInterval()const;
void setPollingInterval(int pollingInterval);
bool getEnabled()const;
void setEnabled(bool enabled);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getServerSideCmk()const;
void setServerSideCmk(const std::string& serverSideCmk);
bool getServerSideEncryption()const;
void setServerSideEncryption(bool serverSideEncryption);
bool getIgnoreDelete()const;
void setIgnoreDelete(bool ignoreDelete);
long getLagPeriod()const;
void setLagPeriod(long lagPeriod);
bool getDirectIO()const;
void setDirectIO(bool directIO);
bool getClientSideEncryption()const;
void setClientSideEncryption(bool clientSideEncryption);
bool getOssBucketSsl()const;
void setOssBucketSsl(bool ossBucketSsl);
bool getRemoteSync()const;
void setRemoteSync(bool remoteSync);
int getFrontendLimit()const;
void setFrontendLimit(int frontendLimit);
private:
bool inPlace_;
std::string ossEndpoint_;
std::string readWriteClientList_;
int backendLimit_;
std::string squash_;
std::string readOnlyClientList_;
std::string securityToken_;
long kmsRotatePeriod_;
bool remoteSyncDownload_;
std::string shareProtocol_;
bool nfsV4Optimization_;
bool accessBasedEnumeration_;
std::string gatewayId_;
bool supportArchive_;
std::string cacheMode_;
std::string localFilePath_;
std::string partialSyncPaths_;
int downloadLimit_;
std::string readOnlyUserList_;
bool fastReclaim_;
bool windowsAcl_;
std::string name_;
std::string ossBucketName_;
bool transferAcceleration_;
std::string clientSideCmk_;
std::string pathPrefix_;
bool browsable_;
std::string readWriteUserList_;
int pollingInterval_;
bool enabled_;
std::string accessKeyId_;
std::string serverSideCmk_;
bool serverSideEncryption_;
bool ignoreDelete_;
long lagPeriod_;
bool directIO_;
bool clientSideEncryption_;
bool ossBucketSsl_;
bool remoteSync_;
int frontendLimit_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYFILESHAREREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/CreateGatewayFileShareResult.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_SGW_MODEL_CREATEGATEWAYFILESHARERESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYFILESHARERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewayFileShareResult : public ServiceResult
{
public:
CreateGatewayFileShareResult();
explicit CreateGatewayFileShareResult(const std::string &payload);
~CreateGatewayFileShareResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYFILESHARERESULT_H_

60
sgw/include/alibabacloud/sgw/model/CreateGatewayLoggingRequest.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_SGW_MODEL_CREATEGATEWAYLOGGINGREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYLOGGINGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewayLoggingRequest : public RpcServiceRequest
{
public:
CreateGatewayLoggingRequest();
~CreateGatewayLoggingRequest();
std::string getSlsLogstore()const;
void setSlsLogstore(const std::string& slsLogstore);
std::string getSlsProject()const;
void setSlsProject(const std::string& slsProject);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string slsLogstore_;
std::string slsProject_;
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYLOGGINGREQUEST_H_

55
sgw/include/alibabacloud/sgw/model/CreateGatewayLoggingResult.h Normal file
View File

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

96
sgw/include/alibabacloud/sgw/model/CreateGatewayRequest.h Normal file
View File

@@ -0,0 +1,96 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewayRequest : public RpcServiceRequest
{
public:
CreateGatewayRequest();
~CreateGatewayRequest();
std::string getGatewayClass()const;
void setGatewayClass(const std::string& gatewayClass);
std::string getGatewayVersion()const;
void setGatewayVersion(const std::string& gatewayVersion);
long getInitCacheSize()const;
void setInitCacheSize(long initCacheSize);
bool getPostPaid()const;
void setPostPaid(bool postPaid);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getType()const;
void setType(const std::string& type);
bool getReleaseAfterExpiration()const;
void setReleaseAfterExpiration(bool releaseAfterExpiration);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getStorageBundleId()const;
void setStorageBundleId(const std::string& storageBundleId);
std::string getInitCacheConfig()const;
void setInitCacheConfig(const std::string& initCacheConfig);
std::string getInitCacheCategory()const;
void setInitCacheCategory(const std::string& initCacheCategory);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getName()const;
void setName(const std::string& name);
std::string getLocation()const;
void setLocation(const std::string& location);
std::string getCategory()const;
void setCategory(const std::string& category);
int getPublicNetworkBandwidth()const;
void setPublicNetworkBandwidth(int publicNetworkBandwidth);
private:
std::string gatewayClass_;
std::string gatewayVersion_;
long initCacheSize_;
bool postPaid_;
std::string description_;
std::string type_;
bool releaseAfterExpiration_;
std::string accessKeyId_;
std::string securityToken_;
std::string storageBundleId_;
std::string initCacheConfig_;
std::string initCacheCategory_;
std::string vSwitchId_;
std::string name_;
std::string location_;
std::string category_;
int publicNetworkBandwidth_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYREQUEST_H_

59
sgw/include/alibabacloud/sgw/model/CreateGatewayResult.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_SGW_MODEL_CREATEGATEWAYRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewayResult : public ServiceResult
{
public:
CreateGatewayResult();
explicit CreateGatewayResult(const std::string &payload);
~CreateGatewayResult();
std::string getBuyURL()const;
std::string getMessage()const;
std::string getGatewayId()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string buyURL_;
std::string message_;
std::string gatewayId_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYRESULT_H_

60
sgw/include/alibabacloud/sgw/model/CreateGatewaySMBUserRequest.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_SGW_MODEL_CREATEGATEWAYSMBUSERREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYSMBUSERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewaySMBUserRequest : public RpcServiceRequest
{
public:
CreateGatewaySMBUserRequest();
~CreateGatewaySMBUserRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getPassword()const;
void setPassword(const std::string& password);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
std::string getUsername()const;
void setUsername(const std::string& username);
private:
std::string accessKeyId_;
std::string password_;
std::string securityToken_;
std::string gatewayId_;
std::string username_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYSMBUSERREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/CreateGatewaySMBUserResult.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_SGW_MODEL_CREATEGATEWAYSMBUSERRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYSMBUSERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateGatewaySMBUserResult : public ServiceResult
{
public:
CreateGatewaySMBUserResult();
explicit CreateGatewaySMBUserResult(const std::string &payload);
~CreateGatewaySMBUserResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATEGATEWAYSMBUSERRESULT_H_

66
sgw/include/alibabacloud/sgw/model/CreateStorageBundleRequest.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_SGW_MODEL_CREATESTORAGEBUNDLEREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_CREATESTORAGEBUNDLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateStorageBundleRequest : public RpcServiceRequest
{
public:
CreateStorageBundleRequest();
~CreateStorageBundleRequest();
std::string getBackendBucketRegionId()const;
void setBackendBucketRegionId(const std::string& backendBucketRegionId);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getName()const;
void setName(const std::string& name);
std::string getLocation()const;
void setLocation(const std::string& location);
private:
std::string backendBucketRegionId_;
std::string description_;
std::string accessKeyId_;
std::string resourceGroupId_;
std::string securityToken_;
std::string name_;
std::string location_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATESTORAGEBUNDLEREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/CreateStorageBundleResult.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_SGW_MODEL_CREATESTORAGEBUNDLERESULT_H_
#define ALIBABACLOUD_SGW_MODEL_CREATESTORAGEBUNDLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT CreateStorageBundleResult : public ServiceResult
{
public:
CreateStorageBundleResult();
explicit CreateStorageBundleResult(const std::string &payload);
~CreateStorageBundleResult();
std::string getMessage()const;
std::string getStorageBundleId()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string storageBundleId_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_CREATESTORAGEBUNDLERESULT_H_

54
sgw/include/alibabacloud/sgw/model/DeleteExpressSyncRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DELETEEXPRESSSYNCREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEEXPRESSSYNCREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteExpressSyncRequest : public RpcServiceRequest
{
public:
DeleteExpressSyncRequest();
~DeleteExpressSyncRequest();
std::string getExpressSyncId()const;
void setExpressSyncId(const std::string& expressSyncId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
private:
std::string expressSyncId_;
std::string accessKeyId_;
std::string securityToken_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEEXPRESSSYNCREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DeleteExpressSyncResult.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_SGW_MODEL_DELETEEXPRESSSYNCRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEEXPRESSSYNCRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteExpressSyncResult : public ServiceResult
{
public:
DeleteExpressSyncResult();
explicit DeleteExpressSyncResult(const std::string &payload);
~DeleteExpressSyncResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEEXPRESSSYNCRESULT_H_

60
sgw/include/alibabacloud/sgw/model/DeleteGatewayBlockVolumesRequest.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_SGW_MODEL_DELETEGATEWAYBLOCKVOLUMESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYBLOCKVOLUMESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewayBlockVolumesRequest : public RpcServiceRequest
{
public:
DeleteGatewayBlockVolumesRequest();
~DeleteGatewayBlockVolumesRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
bool getIsSourceDeletion()const;
void setIsSourceDeletion(bool isSourceDeletion);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getIndexId()const;
void setIndexId(const std::string& indexId);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
bool isSourceDeletion_;
std::string securityToken_;
std::string indexId_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYBLOCKVOLUMESREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DeleteGatewayBlockVolumesResult.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_SGW_MODEL_DELETEGATEWAYBLOCKVOLUMESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYBLOCKVOLUMESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewayBlockVolumesResult : public ServiceResult
{
public:
DeleteGatewayBlockVolumesResult();
explicit DeleteGatewayBlockVolumesResult(const std::string &payload);
~DeleteGatewayBlockVolumesResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYBLOCKVOLUMESRESULT_H_

60
sgw/include/alibabacloud/sgw/model/DeleteGatewayCacheDiskRequest.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_SGW_MODEL_DELETEGATEWAYCACHEDISKREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYCACHEDISKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewayCacheDiskRequest : public RpcServiceRequest
{
public:
DeleteGatewayCacheDiskRequest();
~DeleteGatewayCacheDiskRequest();
std::string getLocalFilePath()const;
void setLocalFilePath(const std::string& localFilePath);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getCacheId()const;
void setCacheId(const std::string& cacheId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string localFilePath_;
std::string accessKeyId_;
std::string cacheId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYCACHEDISKREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DeleteGatewayCacheDiskResult.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_SGW_MODEL_DELETEGATEWAYCACHEDISKRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYCACHEDISKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewayCacheDiskResult : public ServiceResult
{
public:
DeleteGatewayCacheDiskResult();
explicit DeleteGatewayCacheDiskResult(const std::string &payload);
~DeleteGatewayCacheDiskResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYCACHEDISKRESULT_H_

60
sgw/include/alibabacloud/sgw/model/DeleteGatewayFileSharesRequest.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_SGW_MODEL_DELETEGATEWAYFILESHARESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYFILESHARESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewayFileSharesRequest : public RpcServiceRequest
{
public:
DeleteGatewayFileSharesRequest();
~DeleteGatewayFileSharesRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getIndexId()const;
void setIndexId(const std::string& indexId);
bool getForce()const;
void setForce(bool force);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string indexId_;
bool force_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYFILESHARESREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DeleteGatewayFileSharesResult.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_SGW_MODEL_DELETEGATEWAYFILESHARESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYFILESHARESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewayFileSharesResult : public ServiceResult
{
public:
DeleteGatewayFileSharesResult();
explicit DeleteGatewayFileSharesResult(const std::string &payload);
~DeleteGatewayFileSharesResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYFILESHARESRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DeleteGatewayLoggingRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYLOGGINGREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYLOGGINGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewayLoggingRequest : public RpcServiceRequest
{
public:
DeleteGatewayLoggingRequest();
~DeleteGatewayLoggingRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYLOGGINGREQUEST_H_

55
sgw/include/alibabacloud/sgw/model/DeleteGatewayLoggingResult.h Normal file
View File

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

54
sgw/include/alibabacloud/sgw/model/DeleteGatewayRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewayRequest : public RpcServiceRequest
{
public:
DeleteGatewayRequest();
~DeleteGatewayRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DeleteGatewayResult.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_SGW_MODEL_DELETEGATEWAYRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewayResult : public ServiceResult
{
public:
DeleteGatewayResult();
explicit DeleteGatewayResult(const std::string &payload);
~DeleteGatewayResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYRESULT_H_

57
sgw/include/alibabacloud/sgw/model/DeleteGatewaySMBUserRequest.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_SGW_MODEL_DELETEGATEWAYSMBUSERREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYSMBUSERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewaySMBUserRequest : public RpcServiceRequest
{
public:
DeleteGatewaySMBUserRequest();
~DeleteGatewaySMBUserRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
std::string getUsername()const;
void setUsername(const std::string& username);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
std::string username_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYSMBUSERREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DeleteGatewaySMBUserResult.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_SGW_MODEL_DELETEGATEWAYSMBUSERRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYSMBUSERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteGatewaySMBUserResult : public ServiceResult
{
public:
DeleteGatewaySMBUserResult();
explicit DeleteGatewaySMBUserResult(const std::string &payload);
~DeleteGatewaySMBUserResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETEGATEWAYSMBUSERRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DeleteStorageBundleRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DELETESTORAGEBUNDLEREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DELETESTORAGEBUNDLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeleteStorageBundleRequest : public RpcServiceRequest
{
public:
DeleteStorageBundleRequest();
~DeleteStorageBundleRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getStorageBundleId()const;
void setStorageBundleId(const std::string& storageBundleId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string storageBundleId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DELETESTORAGEBUNDLEREQUEST_H_

55
sgw/include/alibabacloud/sgw/model/DeleteStorageBundleResult.h Normal file
View File

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

63
sgw/include/alibabacloud/sgw/model/DeployCacheDiskRequest.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_SGW_MODEL_DEPLOYCACHEDISKREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DEPLOYCACHEDISKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeployCacheDiskRequest : public RpcServiceRequest
{
public:
DeployCacheDiskRequest();
~DeployCacheDiskRequest();
int getSizeInGB()const;
void setSizeInGB(int sizeInGB);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getCacheConfig()const;
void setCacheConfig(const std::string& cacheConfig);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDiskCategory()const;
void setDiskCategory(const std::string& diskCategory);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
int sizeInGB_;
std::string accessKeyId_;
std::string cacheConfig_;
std::string securityToken_;
std::string diskCategory_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DEPLOYCACHEDISKREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DeployCacheDiskResult.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_SGW_MODEL_DEPLOYCACHEDISKRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DEPLOYCACHEDISKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeployCacheDiskResult : public ServiceResult
{
public:
DeployCacheDiskResult();
explicit DeployCacheDiskResult(const std::string &payload);
~DeployCacheDiskResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DEPLOYCACHEDISKRESULT_H_

73
sgw/include/alibabacloud/sgw/model/DeployGatewayRequest.h Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DEPLOYGATEWAYREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DEPLOYGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeployGatewayRequest : public RpcServiceRequest
{
public:
struct DataDisk
{
int size;
std::string category;
std::string cacheConfig;
};
public:
DeployGatewayRequest();
~DeployGatewayRequest();
std::string getGatewayClass()const;
void setGatewayClass(const std::string& gatewayClass);
std::string getGatewayVersion()const;
void setGatewayVersion(const std::string& gatewayVersion);
std::vector<DataDisk> getDataDisk()const;
void setDataDisk(const std::vector<DataDisk>& dataDisk);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string gatewayClass_;
std::string gatewayVersion_;
std::vector<DataDisk> dataDisk_;
std::string accessKeyId_;
std::string vSwitchId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DEPLOYGATEWAYREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DeployGatewayResult.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_SGW_MODEL_DEPLOYGATEWAYRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DEPLOYGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DeployGatewayResult : public ServiceResult
{
public:
DeployGatewayResult();
explicit DeployGatewayResult(const std::string &payload);
~DeployGatewayResult();
std::string getTaskId()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DEPLOYGATEWAYRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DescribeAccountConfigRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEACCOUNTCONFIGREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEACCOUNTCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeAccountConfigRequest : public RpcServiceRequest
{
public:
DescribeAccountConfigRequest();
~DescribeAccountConfigRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEACCOUNTCONFIGREQUEST_H_

63
sgw/include/alibabacloud/sgw/model/DescribeAccountConfigResult.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_SGW_MODEL_DESCRIBEACCOUNTCONFIGRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEACCOUNTCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeAccountConfigResult : public ServiceResult
{
public:
DescribeAccountConfigResult();
explicit DescribeAccountConfigResult(const std::string &payload);
~DescribeAccountConfigResult();
std::string getMessage()const;
bool getIsSupportServerSideEncryption()const;
bool getIsSupportClientSideEncryption()const;
std::string getCode()const;
bool getIsSupportGatewayLogging()const;
bool getSuccess()const;
bool getIsSupportElasticGatewayBeta()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
bool isSupportServerSideEncryption_;
bool isSupportClientSideEncryption_;
std::string code_;
bool isSupportGatewayLogging_;
bool success_;
bool isSupportElasticGatewayBeta_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEACCOUNTCONFIGRESULT_H_

63
sgw/include/alibabacloud/sgw/model/DescribeBlockVolumeSnapshotsRequest.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_SGW_MODEL_DESCRIBEBLOCKVOLUMESNAPSHOTSREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEBLOCKVOLUMESNAPSHOTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeBlockVolumeSnapshotsRequest : public RpcServiceRequest
{
public:
DescribeBlockVolumeSnapshotsRequest();
~DescribeBlockVolumeSnapshotsRequest();
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getIndexId()const;
void setIndexId(const std::string& indexId);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
int pageNumber_;
std::string accessKeyId_;
std::string securityToken_;
int pageSize_;
std::string indexId_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEBLOCKVOLUMESNAPSHOTSREQUEST_H_

69
sgw/include/alibabacloud/sgw/model/DescribeBlockVolumeSnapshotsResult.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_SGW_MODEL_DESCRIBEBLOCKVOLUMESNAPSHOTSRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEBLOCKVOLUMESNAPSHOTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeBlockVolumeSnapshotsResult : public ServiceResult
{
public:
struct Snapshot
{
long size;
long createTime;
std::string snapshotName;
};
DescribeBlockVolumeSnapshotsResult();
explicit DescribeBlockVolumeSnapshotsResult(const std::string &payload);
~DescribeBlockVolumeSnapshotsResult();
int getTotalCount()const;
std::string getMessage()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<Snapshot> getSnapshots()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
std::string message_;
int pageSize_;
int pageNumber_;
std::vector<Snapshot> snapshots_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEBLOCKVOLUMESNAPSHOTSRESULT_H_

57
sgw/include/alibabacloud/sgw/model/DescribeDashboardRequest.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_SGW_MODEL_DESCRIBEDASHBOARDREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEDASHBOARDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeDashboardRequest : public RpcServiceRequest
{
public:
DescribeDashboardRequest();
~DescribeDashboardRequest();
std::string getBackendBucketRegionId()const;
void setBackendBucketRegionId(const std::string& backendBucketRegionId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
private:
std::string backendBucketRegionId_;
std::string accessKeyId_;
std::string resourceGroupId_;
std::string securityToken_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEDASHBOARDREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DescribeDashboardResult.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_SGW_MODEL_DESCRIBEDASHBOARDRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEDASHBOARDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeDashboardResult : public ServiceResult
{
public:
DescribeDashboardResult();
explicit DescribeDashboardResult(const std::string &payload);
~DescribeDashboardResult();
std::string getMessage()const;
std::string getOverview()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string overview_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEDASHBOARDRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DescribeExpireCachesRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPIRECACHESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPIRECACHESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeExpireCachesRequest : public RpcServiceRequest
{
public:
DescribeExpireCachesRequest();
~DescribeExpireCachesRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPIRECACHESREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DescribeExpireCachesResult.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_SGW_MODEL_DESCRIBEEXPIRECACHESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPIRECACHESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeExpireCachesResult : public ServiceResult
{
public:
DescribeExpireCachesResult();
explicit DescribeExpireCachesResult(const std::string &payload);
~DescribeExpireCachesResult();
std::string getMessage()const;
std::string getCacheFilePaths()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string cacheFilePaths_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPIRECACHESRESULT_H_

60
sgw/include/alibabacloud/sgw/model/DescribeExpressSyncSharesRequest.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_SGW_MODEL_DESCRIBEEXPRESSSYNCSHARESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPRESSSYNCSHARESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeExpressSyncSharesRequest : public RpcServiceRequest
{
public:
DescribeExpressSyncSharesRequest();
~DescribeExpressSyncSharesRequest();
bool getIsExternal()const;
void setIsExternal(bool isExternal);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getExpressSyncIds()const;
void setExpressSyncIds(const std::string& expressSyncIds);
bool getIsCrossRegion()const;
void setIsCrossRegion(bool isCrossRegion);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
private:
bool isExternal_;
std::string accessKeyId_;
std::string expressSyncIds_;
bool isCrossRegion_;
std::string securityToken_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPRESSSYNCSHARESREQUEST_H_

69
sgw/include/alibabacloud/sgw/model/DescribeExpressSyncSharesResult.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_SGW_MODEL_DESCRIBEEXPRESSSYNCSHARESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPRESSSYNCSHARESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeExpressSyncSharesResult : public ServiceResult
{
public:
struct Share
{
std::string storageBundleId;
std::string gatewayRegion;
std::string shareName;
std::string expressSyncState;
std::string gatewayName;
std::string gatewayId;
std::string expressSyncId;
int syncProgress;
std::string mnsQueue;
};
DescribeExpressSyncSharesResult();
explicit DescribeExpressSyncSharesResult(const std::string &payload);
~DescribeExpressSyncSharesResult();
std::string getMessage()const;
std::vector<Share> getShares()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<Share> shares_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPRESSSYNCSHARESRESULT_H_

57
sgw/include/alibabacloud/sgw/model/DescribeExpressSyncsRequest.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_SGW_MODEL_DESCRIBEEXPRESSSYNCSREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPRESSSYNCSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeExpressSyncsRequest : public RpcServiceRequest
{
public:
DescribeExpressSyncsRequest();
~DescribeExpressSyncsRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getBucketName()const;
void setBucketName(const std::string& bucketName);
std::string getBucketPrefix()const;
void setBucketPrefix(const std::string& bucketPrefix);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string bucketName_;
std::string bucketPrefix_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPRESSSYNCSREQUEST_H_

67
sgw/include/alibabacloud/sgw/model/DescribeExpressSyncsResult.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_SGW_MODEL_DESCRIBEEXPRESSSYNCSRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPRESSSYNCSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeExpressSyncsResult : public ServiceResult
{
public:
struct ExpressSync
{
std::string description;
std::string bucketName;
std::string bucketRegion;
std::string mnsTopic;
std::string bucketPrefix;
std::string expressSyncId;
std::string name;
};
DescribeExpressSyncsResult();
explicit DescribeExpressSyncsResult(const std::string &payload);
~DescribeExpressSyncsResult();
std::vector<ExpressSync> getExpressSyncs()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ExpressSync> expressSyncs_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEEXPRESSSYNCSRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DescribeGatewayADInfoRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYADINFOREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYADINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayADInfoRequest : public RpcServiceRequest
{
public:
DescribeGatewayADInfoRequest();
~DescribeGatewayADInfoRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYADINFOREQUEST_H_

63
sgw/include/alibabacloud/sgw/model/DescribeGatewayADInfoResult.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_SGW_MODEL_DESCRIBEGATEWAYADINFORESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYADINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayADInfoResult : public ServiceResult
{
public:
DescribeGatewayADInfoResult();
explicit DescribeGatewayADInfoResult(const std::string &payload);
~DescribeGatewayADInfoResult();
std::string getMessage()const;
std::string getUsername()const;
std::string getDomainName()const;
bool getIsEnabled()const;
std::string getServerIp()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string username_;
std::string domainName_;
bool isEnabled_;
std::string serverIp_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYADINFORESULT_H_

54
sgw/include/alibabacloud/sgw/model/DescribeGatewayActionsRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYACTIONSREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYACTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayActionsRequest : public RpcServiceRequest
{
public:
DescribeGatewayActionsRequest();
~DescribeGatewayActionsRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYACTIONSREQUEST_H_

68
sgw/include/alibabacloud/sgw/model/DescribeGatewayActionsResult.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_SGW_MODEL_DESCRIBEGATEWAYACTIONSRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYACTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayActionsResult : public ServiceResult
{
public:
struct Action
{
std::string smbUser;
std::string target;
std::string monitor;
std::string adLdap;
std::string self;
std::string gatewayId;
std::string disk;
std::string cache;
};
DescribeGatewayActionsResult();
explicit DescribeGatewayActionsResult(const std::string &payload);
~DescribeGatewayActionsResult();
std::string getMessage()const;
std::vector<Action> getActions()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<Action> actions_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYACTIONSRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DescribeGatewayAuthInfoRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYAUTHINFOREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYAUTHINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayAuthInfoRequest : public RpcServiceRequest
{
public:
DescribeGatewayAuthInfoRequest();
~DescribeGatewayAuthInfoRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYAUTHINFOREQUEST_H_

61
sgw/include/alibabacloud/sgw/model/DescribeGatewayAuthInfoResult.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_SGW_MODEL_DESCRIBEGATEWAYAUTHINFORESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYAUTHINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayAuthInfoResult : public ServiceResult
{
public:
DescribeGatewayAuthInfoResult();
explicit DescribeGatewayAuthInfoResult(const std::string &payload);
~DescribeGatewayAuthInfoResult();
std::string getMessage()const;
std::string getPublicIp()const;
std::string getUsername()const;
std::string getCode()const;
bool getSuccess()const;
std::string getPassword()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string publicIp_;
std::string username_;
std::string code_;
bool success_;
std::string password_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYAUTHINFORESULT_H_

60
sgw/include/alibabacloud/sgw/model/DescribeGatewayBlockVolumesRequest.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_SGW_MODEL_DESCRIBEGATEWAYBLOCKVOLUMESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYBLOCKVOLUMESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayBlockVolumesRequest : public RpcServiceRequest
{
public:
DescribeGatewayBlockVolumesRequest();
~DescribeGatewayBlockVolumesRequest();
bool getRefresh()const;
void setRefresh(bool refresh);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getIndexId()const;
void setIndexId(const std::string& indexId);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
bool refresh_;
std::string accessKeyId_;
std::string securityToken_;
std::string indexId_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYBLOCKVOLUMESREQUEST_H_

86
sgw/include/alibabacloud/sgw/model/DescribeGatewayBlockVolumesResult.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_SGW_MODEL_DESCRIBEGATEWAYBLOCKVOLUMESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYBLOCKVOLUMESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayBlockVolumesResult : public ServiceResult
{
public:
struct BlockVolume
{
long totalDownload;
std::string address;
long totalUpload;
int lunId;
std::string chapOutUser;
long size;
int port;
bool chapEnabled;
std::string localPath;
std::string cacheMode;
std::string name;
std::string diskType;
std::string target;
std::string ossEndpoint;
std::string protocol;
int status;
std::string indexId;
bool enabled;
int volumeState;
bool ossBucketSsl;
int chunkSize;
std::string serialNumber;
std::string state;
std::string ossBucketName;
std::string chapInUser;
std::string diskId;
};
DescribeGatewayBlockVolumesResult();
explicit DescribeGatewayBlockVolumesResult(const std::string &payload);
~DescribeGatewayBlockVolumesResult();
std::vector<BlockVolume> getBlockVolumes()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::vector<BlockVolume> blockVolumes_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYBLOCKVOLUMESRESULT_H_

60
sgw/include/alibabacloud/sgw/model/DescribeGatewayBucketCachesRequest.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_SGW_MODEL_DESCRIBEGATEWAYBUCKETCACHESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYBUCKETCACHESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayBucketCachesRequest : public RpcServiceRequest
{
public:
DescribeGatewayBucketCachesRequest();
~DescribeGatewayBucketCachesRequest();
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getBucketName()const;
void setBucketName(const std::string& bucketName);
int getPageSize()const;
void setPageSize(int pageSize);
private:
int pageNumber_;
std::string accessKeyId_;
std::string securityToken_;
std::string bucketName_;
int pageSize_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYBUCKETCACHESREQUEST_H_

80
sgw/include/alibabacloud/sgw/model/DescribeGatewayBucketCachesResult.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYBUCKETCACHESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYBUCKETCACHESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayBucketCachesResult : public ServiceResult
{
public:
struct BucketCache
{
std::string category;
std::string shareName;
std::string cacheMode;
std::string gatewayId;
std::string mountPoint;
std::string type;
std::string bucketName;
std::string vpcId;
std::string vpcCidr;
std::string cacheStats;
std::string gatewayName;
std::string regionId;
std::string protocol;
std::string location;
};
DescribeGatewayBucketCachesResult();
explicit DescribeGatewayBucketCachesResult(const std::string &payload);
~DescribeGatewayBucketCachesResult();
int getTotalCount()const;
std::string getMessage()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<BucketCache> getBucketCaches()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
std::string message_;
int pageSize_;
int pageNumber_;
std::vector<BucketCache> bucketCaches_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYBUCKETCACHESRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DescribeGatewayCachesRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCACHESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCACHESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayCachesRequest : public RpcServiceRequest
{
public:
DescribeGatewayCachesRequest();
~DescribeGatewayCachesRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCACHESREQUEST_H_

71
sgw/include/alibabacloud/sgw/model/DescribeGatewayCachesResult.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_SGW_MODEL_DESCRIBEGATEWAYCACHESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCACHESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayCachesResult : public ServiceResult
{
public:
struct Cache
{
long sizeInGB;
std::string buyURL;
std::string renewURL;
std::string cacheId;
std::string performanceLevel;
long expiredTime;
int expireStatus;
bool isUsed;
long iops;
std::string localFilePath;
std::string cacheType;
};
DescribeGatewayCachesResult();
explicit DescribeGatewayCachesResult(const std::string &payload);
~DescribeGatewayCachesResult();
std::string getMessage()const;
std::vector<Cache> getCaches()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<Cache> caches_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCACHESRESULT_H_

57
sgw/include/alibabacloud/sgw/model/DescribeGatewayCapacityLimitRequest.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_SGW_MODEL_DESCRIBEGATEWAYCAPACITYLIMITREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCAPACITYLIMITREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayCapacityLimitRequest : public RpcServiceRequest
{
public:
DescribeGatewayCapacityLimitRequest();
~DescribeGatewayCapacityLimitRequest();
long getSizeInGB()const;
void setSizeInGB(long sizeInGB);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
long sizeInGB_;
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCAPACITYLIMITREQUEST_H_

61
sgw/include/alibabacloud/sgw/model/DescribeGatewayCapacityLimitResult.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_SGW_MODEL_DESCRIBEGATEWAYCAPACITYLIMITRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCAPACITYLIMITRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayCapacityLimitResult : public ServiceResult
{
public:
DescribeGatewayCapacityLimitResult();
explicit DescribeGatewayCapacityLimitResult(const std::string &payload);
~DescribeGatewayCapacityLimitResult();
long getFileSystemSizeInTB()const;
std::string getMessage()const;
std::string getCode()const;
long getFileNumber()const;
bool getIsMetadataSeparate()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
long fileSystemSizeInTB_;
std::string message_;
std::string code_;
long fileNumber_;
bool isMetadataSeparate_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCAPACITYLIMITRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DescribeGatewayCategoriesRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCATEGORIESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCATEGORIESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayCategoriesRequest : public RpcServiceRequest
{
public:
DescribeGatewayCategoriesRequest();
~DescribeGatewayCategoriesRequest();
std::string getGatewayLocation()const;
void setGatewayLocation(const std::string& gatewayLocation);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
private:
std::string gatewayLocation_;
std::string accessKeyId_;
std::string securityToken_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCATEGORIESREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DescribeGatewayCategoriesResult.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_SGW_MODEL_DESCRIBEGATEWAYCATEGORIESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCATEGORIESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayCategoriesResult : public ServiceResult
{
public:
DescribeGatewayCategoriesResult();
explicit DescribeGatewayCategoriesResult(const std::string &payload);
~DescribeGatewayCategoriesResult();
std::string getMessage()const;
std::string getCategories()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string categories_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCATEGORIESRESULT_H_

51
sgw/include/alibabacloud/sgw/model/DescribeGatewayClassesRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCLASSESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCLASSESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayClassesRequest : public RpcServiceRequest
{
public:
DescribeGatewayClassesRequest();
~DescribeGatewayClassesRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
private:
std::string accessKeyId_;
std::string securityToken_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCLASSESREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DescribeGatewayClassesResult.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_SGW_MODEL_DESCRIBEGATEWAYCLASSESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCLASSESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayClassesResult : public ServiceResult
{
public:
DescribeGatewayClassesResult();
explicit DescribeGatewayClassesResult(const std::string &payload);
~DescribeGatewayClassesResult();
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
std::string getClasses()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string code_;
bool success_;
std::string classes_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCLASSESRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DescribeGatewayCredentialRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCREDENTIALREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCREDENTIALREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayCredentialRequest : public RpcServiceRequest
{
public:
DescribeGatewayCredentialRequest();
~DescribeGatewayCredentialRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCREDENTIALREQUEST_H_

67
sgw/include/alibabacloud/sgw/model/DescribeGatewayCredentialResult.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_SGW_MODEL_DESCRIBEGATEWAYCREDENTIALRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCREDENTIALRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayCredentialResult : public ServiceResult
{
public:
DescribeGatewayCredentialResult();
explicit DescribeGatewayCredentialResult(const std::string &payload);
~DescribeGatewayCredentialResult();
std::string getMessage()const;
std::string getVpcId()const;
std::string getEcsIp()const;
std::string getConsoleUsername()const;
std::string getVSwitchId()const;
std::string getConsolePassword()const;
std::string getEcsPassword()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string vpcId_;
std::string ecsIp_;
std::string consoleUsername_;
std::string vSwitchId_;
std::string consolePassword_;
std::string ecsPassword_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYCREDENTIALRESULT_H_

54
sgw/include/alibabacloud/sgw/model/DescribeGatewayDNSRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYDNSREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYDNSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayDNSRequest : public RpcServiceRequest
{
public:
DescribeGatewayDNSRequest();
~DescribeGatewayDNSRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string securityToken_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYDNSREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DescribeGatewayDNSResult.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_SGW_MODEL_DESCRIBEGATEWAYDNSRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYDNSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayDNSResult : public ServiceResult
{
public:
DescribeGatewayDNSResult();
explicit DescribeGatewayDNSResult(const std::string &payload);
~DescribeGatewayDNSResult();
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
std::string getDnsServer()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string code_;
bool success_;
std::string dnsServer_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYDNSRESULT_H_

60
sgw/include/alibabacloud/sgw/model/DescribeGatewayFileSharesRequest.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_SGW_MODEL_DESCRIBEGATEWAYFILESHARESREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYFILESHARESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayFileSharesRequest : public RpcServiceRequest
{
public:
DescribeGatewayFileSharesRequest();
~DescribeGatewayFileSharesRequest();
bool getRefresh()const;
void setRefresh(bool refresh);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getIndexId()const;
void setIndexId(const std::string& indexId);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
bool refresh_;
std::string accessKeyId_;
std::string securityToken_;
std::string indexId_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYFILESHARESREQUEST_H_

125
sgw/include/alibabacloud/sgw/model/DescribeGatewayFileSharesResult.h Normal file
View File

@@ -0,0 +1,125 @@
/*
* 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_SGW_MODEL_DESCRIBEGATEWAYFILESHARESRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYFILESHARESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayFileSharesResult : public ServiceResult
{
public:
struct FileShare
{
long fileNumLimit;
std::string bucketInfos;
long totalDownload;
long inRate;
std::string address;
long totalUpload;
long size;
int downloadLimit;
long downloadQueue;
std::string localPath;
long ossUsed;
std::string clientSideCmk;
std::string serverSideCmk;
int beLimit;
std::string name;
std::string diskType;
long outRate;
std::string mnsHealth;
bool remoteSyncDownload;
bool clientSideEncryption;
bool supportArchive;
std::string roUserList;
bool browsable;
std::string obsoleteBuckets;
bool bucketsStub;
bool fastReclaim;
long remainingMetaSpace;
int feLimit;
std::string kmsRotatePeriod;
std::string serialNumber;
std::string state;
bool inPlace;
std::string ossBucketName;
int pollingInterval;
std::string diskId;
bool remoteSync;
bool accessBasedEnumeration;
std::string rwUserList;
bool windowsAcl;
long fsSizeLimit;
std::string cacheMode;
bool transferAcceleration;
long downloadRate;
std::string squash;
std::string roClientList;
std::string nfsFullPath;
std::string ossEndpoint;
bool nfsV4Optimization;
bool serverSideEncryption;
std::string protocol;
std::string pathPrefix;
long lagPeriod;
std::string partialSyncPaths;
std::string ossHealth;
std::string indexId;
long activeMessages;
bool enabled;
bool directIO;
bool ossBucketSsl;
std::string expressSyncId;
int syncProgress;
long uploadQueue;
bool ignoreDelete;
std::string rwClientList;
long used;
};
DescribeGatewayFileSharesResult();
explicit DescribeGatewayFileSharesResult(const std::string &payload);
~DescribeGatewayFileSharesResult();
std::vector<FileShare> getFileShares()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::vector<FileShare> fileShares_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYFILESHARESRESULT_H_

60
sgw/include/alibabacloud/sgw/model/DescribeGatewayFileStatusRequest.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_SGW_MODEL_DESCRIBEGATEWAYFILESTATUSREQUEST_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYFILESTATUSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayFileStatusRequest : public RpcServiceRequest
{
public:
DescribeGatewayFileStatusRequest();
~DescribeGatewayFileStatusRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getFilePath()const;
void setFilePath(const std::string& filePath);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getIndexId()const;
void setIndexId(const std::string& indexId);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string accessKeyId_;
std::string filePath_;
std::string securityToken_;
std::string indexId_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYFILESTATUSREQUEST_H_

57
sgw/include/alibabacloud/sgw/model/DescribeGatewayFileStatusResult.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_SGW_MODEL_DESCRIBEGATEWAYFILESTATUSRESULT_H_
#define ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYFILESTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/sgw/SgwExport.h>
namespace AlibabaCloud
{
namespace Sgw
{
namespace Model
{
class ALIBABACLOUD_SGW_EXPORT DescribeGatewayFileStatusResult : public ServiceResult
{
public:
DescribeGatewayFileStatusResult();
explicit DescribeGatewayFileStatusResult(const std::string &payload);
~DescribeGatewayFileStatusResult();
std::string getStatus()const;
std::string getMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string message_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SGW_MODEL_DESCRIBEGATEWAYFILESTATUSRESULT_H_

Some files were not shown because too many files have changed in this diff Show More