StorageGatewayClient.h

 
#pragma once
#include <aws/storagegateway/StorageGateway_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/storagegateway/StorageGatewayServiceClientModel.h>
 
namespace Aws
{
namespace StorageGateway
{
  class AWS_STORAGEGATEWAY_API StorageGatewayClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<StorageGatewayClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef StorageGatewayClientConfiguration ClientConfigurationType;
      typedef StorageGatewayEndpointProvider EndpointProviderType;
 
        StorageGatewayClient(const Aws::StorageGateway::StorageGatewayClientConfiguration& clientConfiguration = Aws::StorageGateway::StorageGatewayClientConfiguration(),
                             std::shared_ptr<StorageGatewayEndpointProviderBase> endpointProvider = nullptr);
 
        StorageGatewayClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<StorageGatewayEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::StorageGateway::StorageGatewayClientConfiguration& clientConfiguration = Aws::StorageGateway::StorageGatewayClientConfiguration());
 
        StorageGatewayClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<StorageGatewayEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::StorageGateway::StorageGatewayClientConfiguration& clientConfiguration = Aws::StorageGateway::StorageGatewayClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        StorageGatewayClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        StorageGatewayClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        StorageGatewayClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~StorageGatewayClient();
 
        virtual Model::ActivateGatewayOutcome ActivateGateway(const Model::ActivateGatewayRequest& request) const;
 
        template<typename ActivateGatewayRequestT = Model::ActivateGatewayRequest>
        Model::ActivateGatewayOutcomeCallable ActivateGatewayCallable(const ActivateGatewayRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::ActivateGateway, request);
        }
 
        template<typename ActivateGatewayRequestT = Model::ActivateGatewayRequest>
        void ActivateGatewayAsync(const ActivateGatewayRequestT& request, const ActivateGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::ActivateGateway, request, handler, context);
        }
 
        virtual Model::AddCacheOutcome AddCache(const Model::AddCacheRequest& request) const;
 
        template<typename AddCacheRequestT = Model::AddCacheRequest>
        Model::AddCacheOutcomeCallable AddCacheCallable(const AddCacheRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::AddCache, request);
        }
 
        template<typename AddCacheRequestT = Model::AddCacheRequest>
        void AddCacheAsync(const AddCacheRequestT& request, const AddCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::AddCache, request, handler, context);
        }
 
        virtual Model::AddTagsToResourceOutcome AddTagsToResource(const Model::AddTagsToResourceRequest& request) const;
 
        template<typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
        Model::AddTagsToResourceOutcomeCallable AddTagsToResourceCallable(const AddTagsToResourceRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::AddTagsToResource, request);
        }
 
        template<typename AddTagsToResourceRequestT = Model::AddTagsToResourceRequest>
        void AddTagsToResourceAsync(const AddTagsToResourceRequestT& request, const AddTagsToResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::AddTagsToResource, request, handler, context);
        }
 
        virtual Model::AddUploadBufferOutcome AddUploadBuffer(const Model::AddUploadBufferRequest& request) const;
 
        template<typename AddUploadBufferRequestT = Model::AddUploadBufferRequest>
        Model::AddUploadBufferOutcomeCallable AddUploadBufferCallable(const AddUploadBufferRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::AddUploadBuffer, request);
        }
 
        template<typename AddUploadBufferRequestT = Model::AddUploadBufferRequest>
        void AddUploadBufferAsync(const AddUploadBufferRequestT& request, const AddUploadBufferResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::AddUploadBuffer, request, handler, context);
        }
 
        virtual Model::AddWorkingStorageOutcome AddWorkingStorage(const Model::AddWorkingStorageRequest& request) const;
 
        template<typename AddWorkingStorageRequestT = Model::AddWorkingStorageRequest>
        Model::AddWorkingStorageOutcomeCallable AddWorkingStorageCallable(const AddWorkingStorageRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::AddWorkingStorage, request);
        }
 
        template<typename AddWorkingStorageRequestT = Model::AddWorkingStorageRequest>
        void AddWorkingStorageAsync(const AddWorkingStorageRequestT& request, const AddWorkingStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::AddWorkingStorage, request, handler, context);
        }
 
        virtual Model::AssignTapePoolOutcome AssignTapePool(const Model::AssignTapePoolRequest& request) const;
 
        template<typename AssignTapePoolRequestT = Model::AssignTapePoolRequest>
        Model::AssignTapePoolOutcomeCallable AssignTapePoolCallable(const AssignTapePoolRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::AssignTapePool, request);
        }
 
        template<typename AssignTapePoolRequestT = Model::AssignTapePoolRequest>
        void AssignTapePoolAsync(const AssignTapePoolRequestT& request, const AssignTapePoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::AssignTapePool, request, handler, context);
        }
 
        virtual Model::AssociateFileSystemOutcome AssociateFileSystem(const Model::AssociateFileSystemRequest& request) const;
 
        template<typename AssociateFileSystemRequestT = Model::AssociateFileSystemRequest>
        Model::AssociateFileSystemOutcomeCallable AssociateFileSystemCallable(const AssociateFileSystemRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::AssociateFileSystem, request);
        }
 
        template<typename AssociateFileSystemRequestT = Model::AssociateFileSystemRequest>
        void AssociateFileSystemAsync(const AssociateFileSystemRequestT& request, const AssociateFileSystemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::AssociateFileSystem, request, handler, context);
        }
 
        virtual Model::AttachVolumeOutcome AttachVolume(const Model::AttachVolumeRequest& request) const;
 
        template<typename AttachVolumeRequestT = Model::AttachVolumeRequest>
        Model::AttachVolumeOutcomeCallable AttachVolumeCallable(const AttachVolumeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::AttachVolume, request);
        }
 
        template<typename AttachVolumeRequestT = Model::AttachVolumeRequest>
        void AttachVolumeAsync(const AttachVolumeRequestT& request, const AttachVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::AttachVolume, request, handler, context);
        }
 
        virtual Model::CancelArchivalOutcome CancelArchival(const Model::CancelArchivalRequest& request) const;
 
        template<typename CancelArchivalRequestT = Model::CancelArchivalRequest>
        Model::CancelArchivalOutcomeCallable CancelArchivalCallable(const CancelArchivalRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CancelArchival, request);
        }
 
        template<typename CancelArchivalRequestT = Model::CancelArchivalRequest>
        void CancelArchivalAsync(const CancelArchivalRequestT& request, const CancelArchivalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CancelArchival, request, handler, context);
        }
 
        virtual Model::CancelRetrievalOutcome CancelRetrieval(const Model::CancelRetrievalRequest& request) const;
 
        template<typename CancelRetrievalRequestT = Model::CancelRetrievalRequest>
        Model::CancelRetrievalOutcomeCallable CancelRetrievalCallable(const CancelRetrievalRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CancelRetrieval, request);
        }
 
        template<typename CancelRetrievalRequestT = Model::CancelRetrievalRequest>
        void CancelRetrievalAsync(const CancelRetrievalRequestT& request, const CancelRetrievalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CancelRetrieval, request, handler, context);
        }
 
        virtual Model::CreateCachediSCSIVolumeOutcome CreateCachediSCSIVolume(const Model::CreateCachediSCSIVolumeRequest& request) const;
 
        template<typename CreateCachediSCSIVolumeRequestT = Model::CreateCachediSCSIVolumeRequest>
        Model::CreateCachediSCSIVolumeOutcomeCallable CreateCachediSCSIVolumeCallable(const CreateCachediSCSIVolumeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CreateCachediSCSIVolume, request);
        }
 
        template<typename CreateCachediSCSIVolumeRequestT = Model::CreateCachediSCSIVolumeRequest>
        void CreateCachediSCSIVolumeAsync(const CreateCachediSCSIVolumeRequestT& request, const CreateCachediSCSIVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CreateCachediSCSIVolume, request, handler, context);
        }
 
        virtual Model::CreateNFSFileShareOutcome CreateNFSFileShare(const Model::CreateNFSFileShareRequest& request) const;
 
        template<typename CreateNFSFileShareRequestT = Model::CreateNFSFileShareRequest>
        Model::CreateNFSFileShareOutcomeCallable CreateNFSFileShareCallable(const CreateNFSFileShareRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CreateNFSFileShare, request);
        }
 
        template<typename CreateNFSFileShareRequestT = Model::CreateNFSFileShareRequest>
        void CreateNFSFileShareAsync(const CreateNFSFileShareRequestT& request, const CreateNFSFileShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CreateNFSFileShare, request, handler, context);
        }
 
        virtual Model::CreateSMBFileShareOutcome CreateSMBFileShare(const Model::CreateSMBFileShareRequest& request) const;
 
        template<typename CreateSMBFileShareRequestT = Model::CreateSMBFileShareRequest>
        Model::CreateSMBFileShareOutcomeCallable CreateSMBFileShareCallable(const CreateSMBFileShareRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CreateSMBFileShare, request);
        }
 
        template<typename CreateSMBFileShareRequestT = Model::CreateSMBFileShareRequest>
        void CreateSMBFileShareAsync(const CreateSMBFileShareRequestT& request, const CreateSMBFileShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CreateSMBFileShare, request, handler, context);
        }
 
        virtual Model::CreateSnapshotOutcome CreateSnapshot(const Model::CreateSnapshotRequest& request) const;
 
        template<typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
        Model::CreateSnapshotOutcomeCallable CreateSnapshotCallable(const CreateSnapshotRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CreateSnapshot, request);
        }
 
        template<typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
        void CreateSnapshotAsync(const CreateSnapshotRequestT& request, const CreateSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CreateSnapshot, request, handler, context);
        }
 
        virtual Model::CreateSnapshotFromVolumeRecoveryPointOutcome CreateSnapshotFromVolumeRecoveryPoint(const Model::CreateSnapshotFromVolumeRecoveryPointRequest& request) const;
 
        template<typename CreateSnapshotFromVolumeRecoveryPointRequestT = Model::CreateSnapshotFromVolumeRecoveryPointRequest>
        Model::CreateSnapshotFromVolumeRecoveryPointOutcomeCallable CreateSnapshotFromVolumeRecoveryPointCallable(const CreateSnapshotFromVolumeRecoveryPointRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CreateSnapshotFromVolumeRecoveryPoint, request);
        }
 
        template<typename CreateSnapshotFromVolumeRecoveryPointRequestT = Model::CreateSnapshotFromVolumeRecoveryPointRequest>
        void CreateSnapshotFromVolumeRecoveryPointAsync(const CreateSnapshotFromVolumeRecoveryPointRequestT& request, const CreateSnapshotFromVolumeRecoveryPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CreateSnapshotFromVolumeRecoveryPoint, request, handler, context);
        }
 
        virtual Model::CreateStorediSCSIVolumeOutcome CreateStorediSCSIVolume(const Model::CreateStorediSCSIVolumeRequest& request) const;
 
        template<typename CreateStorediSCSIVolumeRequestT = Model::CreateStorediSCSIVolumeRequest>
        Model::CreateStorediSCSIVolumeOutcomeCallable CreateStorediSCSIVolumeCallable(const CreateStorediSCSIVolumeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CreateStorediSCSIVolume, request);
        }
 
        template<typename CreateStorediSCSIVolumeRequestT = Model::CreateStorediSCSIVolumeRequest>
        void CreateStorediSCSIVolumeAsync(const CreateStorediSCSIVolumeRequestT& request, const CreateStorediSCSIVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CreateStorediSCSIVolume, request, handler, context);
        }
 
        virtual Model::CreateTapePoolOutcome CreateTapePool(const Model::CreateTapePoolRequest& request) const;
 
        template<typename CreateTapePoolRequestT = Model::CreateTapePoolRequest>
        Model::CreateTapePoolOutcomeCallable CreateTapePoolCallable(const CreateTapePoolRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CreateTapePool, request);
        }
 
        template<typename CreateTapePoolRequestT = Model::CreateTapePoolRequest>
        void CreateTapePoolAsync(const CreateTapePoolRequestT& request, const CreateTapePoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CreateTapePool, request, handler, context);
        }
 
        virtual Model::CreateTapeWithBarcodeOutcome CreateTapeWithBarcode(const Model::CreateTapeWithBarcodeRequest& request) const;
 
        template<typename CreateTapeWithBarcodeRequestT = Model::CreateTapeWithBarcodeRequest>
        Model::CreateTapeWithBarcodeOutcomeCallable CreateTapeWithBarcodeCallable(const CreateTapeWithBarcodeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CreateTapeWithBarcode, request);
        }
 
        template<typename CreateTapeWithBarcodeRequestT = Model::CreateTapeWithBarcodeRequest>
        void CreateTapeWithBarcodeAsync(const CreateTapeWithBarcodeRequestT& request, const CreateTapeWithBarcodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CreateTapeWithBarcode, request, handler, context);
        }
 
        virtual Model::CreateTapesOutcome CreateTapes(const Model::CreateTapesRequest& request) const;
 
        template<typename CreateTapesRequestT = Model::CreateTapesRequest>
        Model::CreateTapesOutcomeCallable CreateTapesCallable(const CreateTapesRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::CreateTapes, request);
        }
 
        template<typename CreateTapesRequestT = Model::CreateTapesRequest>
        void CreateTapesAsync(const CreateTapesRequestT& request, const CreateTapesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::CreateTapes, request, handler, context);
        }
 
        virtual Model::DeleteAutomaticTapeCreationPolicyOutcome DeleteAutomaticTapeCreationPolicy(const Model::DeleteAutomaticTapeCreationPolicyRequest& request) const;
 
        template<typename DeleteAutomaticTapeCreationPolicyRequestT = Model::DeleteAutomaticTapeCreationPolicyRequest>
        Model::DeleteAutomaticTapeCreationPolicyOutcomeCallable DeleteAutomaticTapeCreationPolicyCallable(const DeleteAutomaticTapeCreationPolicyRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteAutomaticTapeCreationPolicy, request);
        }
 
        template<typename DeleteAutomaticTapeCreationPolicyRequestT = Model::DeleteAutomaticTapeCreationPolicyRequest>
        void DeleteAutomaticTapeCreationPolicyAsync(const DeleteAutomaticTapeCreationPolicyRequestT& request, const DeleteAutomaticTapeCreationPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteAutomaticTapeCreationPolicy, request, handler, context);
        }
 
        virtual Model::DeleteBandwidthRateLimitOutcome DeleteBandwidthRateLimit(const Model::DeleteBandwidthRateLimitRequest& request) const;
 
        template<typename DeleteBandwidthRateLimitRequestT = Model::DeleteBandwidthRateLimitRequest>
        Model::DeleteBandwidthRateLimitOutcomeCallable DeleteBandwidthRateLimitCallable(const DeleteBandwidthRateLimitRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteBandwidthRateLimit, request);
        }
 
        template<typename DeleteBandwidthRateLimitRequestT = Model::DeleteBandwidthRateLimitRequest>
        void DeleteBandwidthRateLimitAsync(const DeleteBandwidthRateLimitRequestT& request, const DeleteBandwidthRateLimitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteBandwidthRateLimit, request, handler, context);
        }
 
        virtual Model::DeleteChapCredentialsOutcome DeleteChapCredentials(const Model::DeleteChapCredentialsRequest& request) const;
 
        template<typename DeleteChapCredentialsRequestT = Model::DeleteChapCredentialsRequest>
        Model::DeleteChapCredentialsOutcomeCallable DeleteChapCredentialsCallable(const DeleteChapCredentialsRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteChapCredentials, request);
        }
 
        template<typename DeleteChapCredentialsRequestT = Model::DeleteChapCredentialsRequest>
        void DeleteChapCredentialsAsync(const DeleteChapCredentialsRequestT& request, const DeleteChapCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteChapCredentials, request, handler, context);
        }
 
        virtual Model::DeleteFileShareOutcome DeleteFileShare(const Model::DeleteFileShareRequest& request) const;
 
        template<typename DeleteFileShareRequestT = Model::DeleteFileShareRequest>
        Model::DeleteFileShareOutcomeCallable DeleteFileShareCallable(const DeleteFileShareRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteFileShare, request);
        }
 
        template<typename DeleteFileShareRequestT = Model::DeleteFileShareRequest>
        void DeleteFileShareAsync(const DeleteFileShareRequestT& request, const DeleteFileShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteFileShare, request, handler, context);
        }
 
        virtual Model::DeleteGatewayOutcome DeleteGateway(const Model::DeleteGatewayRequest& request) const;
 
        template<typename DeleteGatewayRequestT = Model::DeleteGatewayRequest>
        Model::DeleteGatewayOutcomeCallable DeleteGatewayCallable(const DeleteGatewayRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteGateway, request);
        }
 
        template<typename DeleteGatewayRequestT = Model::DeleteGatewayRequest>
        void DeleteGatewayAsync(const DeleteGatewayRequestT& request, const DeleteGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteGateway, request, handler, context);
        }
 
        virtual Model::DeleteSnapshotScheduleOutcome DeleteSnapshotSchedule(const Model::DeleteSnapshotScheduleRequest& request) const;
 
        template<typename DeleteSnapshotScheduleRequestT = Model::DeleteSnapshotScheduleRequest>
        Model::DeleteSnapshotScheduleOutcomeCallable DeleteSnapshotScheduleCallable(const DeleteSnapshotScheduleRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteSnapshotSchedule, request);
        }
 
        template<typename DeleteSnapshotScheduleRequestT = Model::DeleteSnapshotScheduleRequest>
        void DeleteSnapshotScheduleAsync(const DeleteSnapshotScheduleRequestT& request, const DeleteSnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteSnapshotSchedule, request, handler, context);
        }
 
        virtual Model::DeleteTapeOutcome DeleteTape(const Model::DeleteTapeRequest& request) const;
 
        template<typename DeleteTapeRequestT = Model::DeleteTapeRequest>
        Model::DeleteTapeOutcomeCallable DeleteTapeCallable(const DeleteTapeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteTape, request);
        }
 
        template<typename DeleteTapeRequestT = Model::DeleteTapeRequest>
        void DeleteTapeAsync(const DeleteTapeRequestT& request, const DeleteTapeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteTape, request, handler, context);
        }
 
        virtual Model::DeleteTapeArchiveOutcome DeleteTapeArchive(const Model::DeleteTapeArchiveRequest& request) const;
 
        template<typename DeleteTapeArchiveRequestT = Model::DeleteTapeArchiveRequest>
        Model::DeleteTapeArchiveOutcomeCallable DeleteTapeArchiveCallable(const DeleteTapeArchiveRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteTapeArchive, request);
        }
 
        template<typename DeleteTapeArchiveRequestT = Model::DeleteTapeArchiveRequest>
        void DeleteTapeArchiveAsync(const DeleteTapeArchiveRequestT& request, const DeleteTapeArchiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteTapeArchive, request, handler, context);
        }
 
        virtual Model::DeleteTapePoolOutcome DeleteTapePool(const Model::DeleteTapePoolRequest& request) const;
 
        template<typename DeleteTapePoolRequestT = Model::DeleteTapePoolRequest>
        Model::DeleteTapePoolOutcomeCallable DeleteTapePoolCallable(const DeleteTapePoolRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteTapePool, request);
        }
 
        template<typename DeleteTapePoolRequestT = Model::DeleteTapePoolRequest>
        void DeleteTapePoolAsync(const DeleteTapePoolRequestT& request, const DeleteTapePoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteTapePool, request, handler, context);
        }
 
        virtual Model::DeleteVolumeOutcome DeleteVolume(const Model::DeleteVolumeRequest& request) const;
 
        template<typename DeleteVolumeRequestT = Model::DeleteVolumeRequest>
        Model::DeleteVolumeOutcomeCallable DeleteVolumeCallable(const DeleteVolumeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DeleteVolume, request);
        }
 
        template<typename DeleteVolumeRequestT = Model::DeleteVolumeRequest>
        void DeleteVolumeAsync(const DeleteVolumeRequestT& request, const DeleteVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DeleteVolume, request, handler, context);
        }
 
        virtual Model::DescribeAvailabilityMonitorTestOutcome DescribeAvailabilityMonitorTest(const Model::DescribeAvailabilityMonitorTestRequest& request) const;
 
        template<typename DescribeAvailabilityMonitorTestRequestT = Model::DescribeAvailabilityMonitorTestRequest>
        Model::DescribeAvailabilityMonitorTestOutcomeCallable DescribeAvailabilityMonitorTestCallable(const DescribeAvailabilityMonitorTestRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeAvailabilityMonitorTest, request);
        }
 
        template<typename DescribeAvailabilityMonitorTestRequestT = Model::DescribeAvailabilityMonitorTestRequest>
        void DescribeAvailabilityMonitorTestAsync(const DescribeAvailabilityMonitorTestRequestT& request, const DescribeAvailabilityMonitorTestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeAvailabilityMonitorTest, request, handler, context);
        }
 
        virtual Model::DescribeBandwidthRateLimitOutcome DescribeBandwidthRateLimit(const Model::DescribeBandwidthRateLimitRequest& request) const;
 
        template<typename DescribeBandwidthRateLimitRequestT = Model::DescribeBandwidthRateLimitRequest>
        Model::DescribeBandwidthRateLimitOutcomeCallable DescribeBandwidthRateLimitCallable(const DescribeBandwidthRateLimitRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeBandwidthRateLimit, request);
        }
 
        template<typename DescribeBandwidthRateLimitRequestT = Model::DescribeBandwidthRateLimitRequest>
        void DescribeBandwidthRateLimitAsync(const DescribeBandwidthRateLimitRequestT& request, const DescribeBandwidthRateLimitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeBandwidthRateLimit, request, handler, context);
        }
 
        virtual Model::DescribeBandwidthRateLimitScheduleOutcome DescribeBandwidthRateLimitSchedule(const Model::DescribeBandwidthRateLimitScheduleRequest& request) const;
 
        template<typename DescribeBandwidthRateLimitScheduleRequestT = Model::DescribeBandwidthRateLimitScheduleRequest>
        Model::DescribeBandwidthRateLimitScheduleOutcomeCallable DescribeBandwidthRateLimitScheduleCallable(const DescribeBandwidthRateLimitScheduleRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeBandwidthRateLimitSchedule, request);
        }
 
        template<typename DescribeBandwidthRateLimitScheduleRequestT = Model::DescribeBandwidthRateLimitScheduleRequest>
        void DescribeBandwidthRateLimitScheduleAsync(const DescribeBandwidthRateLimitScheduleRequestT& request, const DescribeBandwidthRateLimitScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeBandwidthRateLimitSchedule, request, handler, context);
        }
 
        virtual Model::DescribeCacheOutcome DescribeCache(const Model::DescribeCacheRequest& request) const;
 
        template<typename DescribeCacheRequestT = Model::DescribeCacheRequest>
        Model::DescribeCacheOutcomeCallable DescribeCacheCallable(const DescribeCacheRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeCache, request);
        }
 
        template<typename DescribeCacheRequestT = Model::DescribeCacheRequest>
        void DescribeCacheAsync(const DescribeCacheRequestT& request, const DescribeCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeCache, request, handler, context);
        }
 
        virtual Model::DescribeCachediSCSIVolumesOutcome DescribeCachediSCSIVolumes(const Model::DescribeCachediSCSIVolumesRequest& request) const;
 
        template<typename DescribeCachediSCSIVolumesRequestT = Model::DescribeCachediSCSIVolumesRequest>
        Model::DescribeCachediSCSIVolumesOutcomeCallable DescribeCachediSCSIVolumesCallable(const DescribeCachediSCSIVolumesRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeCachediSCSIVolumes, request);
        }
 
        template<typename DescribeCachediSCSIVolumesRequestT = Model::DescribeCachediSCSIVolumesRequest>
        void DescribeCachediSCSIVolumesAsync(const DescribeCachediSCSIVolumesRequestT& request, const DescribeCachediSCSIVolumesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeCachediSCSIVolumes, request, handler, context);
        }
 
        virtual Model::DescribeChapCredentialsOutcome DescribeChapCredentials(const Model::DescribeChapCredentialsRequest& request) const;
 
        template<typename DescribeChapCredentialsRequestT = Model::DescribeChapCredentialsRequest>
        Model::DescribeChapCredentialsOutcomeCallable DescribeChapCredentialsCallable(const DescribeChapCredentialsRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeChapCredentials, request);
        }
 
        template<typename DescribeChapCredentialsRequestT = Model::DescribeChapCredentialsRequest>
        void DescribeChapCredentialsAsync(const DescribeChapCredentialsRequestT& request, const DescribeChapCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeChapCredentials, request, handler, context);
        }
 
        virtual Model::DescribeFileSystemAssociationsOutcome DescribeFileSystemAssociations(const Model::DescribeFileSystemAssociationsRequest& request) const;
 
        template<typename DescribeFileSystemAssociationsRequestT = Model::DescribeFileSystemAssociationsRequest>
        Model::DescribeFileSystemAssociationsOutcomeCallable DescribeFileSystemAssociationsCallable(const DescribeFileSystemAssociationsRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeFileSystemAssociations, request);
        }
 
        template<typename DescribeFileSystemAssociationsRequestT = Model::DescribeFileSystemAssociationsRequest>
        void DescribeFileSystemAssociationsAsync(const DescribeFileSystemAssociationsRequestT& request, const DescribeFileSystemAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeFileSystemAssociations, request, handler, context);
        }
 
        virtual Model::DescribeGatewayInformationOutcome DescribeGatewayInformation(const Model::DescribeGatewayInformationRequest& request) const;
 
        template<typename DescribeGatewayInformationRequestT = Model::DescribeGatewayInformationRequest>
        Model::DescribeGatewayInformationOutcomeCallable DescribeGatewayInformationCallable(const DescribeGatewayInformationRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeGatewayInformation, request);
        }
 
        template<typename DescribeGatewayInformationRequestT = Model::DescribeGatewayInformationRequest>
        void DescribeGatewayInformationAsync(const DescribeGatewayInformationRequestT& request, const DescribeGatewayInformationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeGatewayInformation, request, handler, context);
        }
 
        virtual Model::DescribeMaintenanceStartTimeOutcome DescribeMaintenanceStartTime(const Model::DescribeMaintenanceStartTimeRequest& request) const;
 
        template<typename DescribeMaintenanceStartTimeRequestT = Model::DescribeMaintenanceStartTimeRequest>
        Model::DescribeMaintenanceStartTimeOutcomeCallable DescribeMaintenanceStartTimeCallable(const DescribeMaintenanceStartTimeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeMaintenanceStartTime, request);
        }
 
        template<typename DescribeMaintenanceStartTimeRequestT = Model::DescribeMaintenanceStartTimeRequest>
        void DescribeMaintenanceStartTimeAsync(const DescribeMaintenanceStartTimeRequestT& request, const DescribeMaintenanceStartTimeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeMaintenanceStartTime, request, handler, context);
        }
 
        virtual Model::DescribeNFSFileSharesOutcome DescribeNFSFileShares(const Model::DescribeNFSFileSharesRequest& request) const;
 
        template<typename DescribeNFSFileSharesRequestT = Model::DescribeNFSFileSharesRequest>
        Model::DescribeNFSFileSharesOutcomeCallable DescribeNFSFileSharesCallable(const DescribeNFSFileSharesRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeNFSFileShares, request);
        }
 
        template<typename DescribeNFSFileSharesRequestT = Model::DescribeNFSFileSharesRequest>
        void DescribeNFSFileSharesAsync(const DescribeNFSFileSharesRequestT& request, const DescribeNFSFileSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeNFSFileShares, request, handler, context);
        }
 
        virtual Model::DescribeSMBFileSharesOutcome DescribeSMBFileShares(const Model::DescribeSMBFileSharesRequest& request) const;
 
        template<typename DescribeSMBFileSharesRequestT = Model::DescribeSMBFileSharesRequest>
        Model::DescribeSMBFileSharesOutcomeCallable DescribeSMBFileSharesCallable(const DescribeSMBFileSharesRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeSMBFileShares, request);
        }
 
        template<typename DescribeSMBFileSharesRequestT = Model::DescribeSMBFileSharesRequest>
        void DescribeSMBFileSharesAsync(const DescribeSMBFileSharesRequestT& request, const DescribeSMBFileSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeSMBFileShares, request, handler, context);
        }
 
        virtual Model::DescribeSMBSettingsOutcome DescribeSMBSettings(const Model::DescribeSMBSettingsRequest& request) const;
 
        template<typename DescribeSMBSettingsRequestT = Model::DescribeSMBSettingsRequest>
        Model::DescribeSMBSettingsOutcomeCallable DescribeSMBSettingsCallable(const DescribeSMBSettingsRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeSMBSettings, request);
        }
 
        template<typename DescribeSMBSettingsRequestT = Model::DescribeSMBSettingsRequest>
        void DescribeSMBSettingsAsync(const DescribeSMBSettingsRequestT& request, const DescribeSMBSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeSMBSettings, request, handler, context);
        }
 
        virtual Model::DescribeSnapshotScheduleOutcome DescribeSnapshotSchedule(const Model::DescribeSnapshotScheduleRequest& request) const;
 
        template<typename DescribeSnapshotScheduleRequestT = Model::DescribeSnapshotScheduleRequest>
        Model::DescribeSnapshotScheduleOutcomeCallable DescribeSnapshotScheduleCallable(const DescribeSnapshotScheduleRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeSnapshotSchedule, request);
        }
 
        template<typename DescribeSnapshotScheduleRequestT = Model::DescribeSnapshotScheduleRequest>
        void DescribeSnapshotScheduleAsync(const DescribeSnapshotScheduleRequestT& request, const DescribeSnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeSnapshotSchedule, request, handler, context);
        }
 
        virtual Model::DescribeStorediSCSIVolumesOutcome DescribeStorediSCSIVolumes(const Model::DescribeStorediSCSIVolumesRequest& request) const;
 
        template<typename DescribeStorediSCSIVolumesRequestT = Model::DescribeStorediSCSIVolumesRequest>
        Model::DescribeStorediSCSIVolumesOutcomeCallable DescribeStorediSCSIVolumesCallable(const DescribeStorediSCSIVolumesRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeStorediSCSIVolumes, request);
        }
 
        template<typename DescribeStorediSCSIVolumesRequestT = Model::DescribeStorediSCSIVolumesRequest>
        void DescribeStorediSCSIVolumesAsync(const DescribeStorediSCSIVolumesRequestT& request, const DescribeStorediSCSIVolumesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeStorediSCSIVolumes, request, handler, context);
        }
 
        virtual Model::DescribeTapeArchivesOutcome DescribeTapeArchives(const Model::DescribeTapeArchivesRequest& request = {}) const;
 
        template<typename DescribeTapeArchivesRequestT = Model::DescribeTapeArchivesRequest>
        Model::DescribeTapeArchivesOutcomeCallable DescribeTapeArchivesCallable(const DescribeTapeArchivesRequestT& request = {}) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeTapeArchives, request);
        }
 
        template<typename DescribeTapeArchivesRequestT = Model::DescribeTapeArchivesRequest>
        void DescribeTapeArchivesAsync(const DescribeTapeArchivesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeTapeArchivesRequestT& request = {}) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeTapeArchives, request, handler, context);
        }
 
        virtual Model::DescribeTapeRecoveryPointsOutcome DescribeTapeRecoveryPoints(const Model::DescribeTapeRecoveryPointsRequest& request) const;
 
        template<typename DescribeTapeRecoveryPointsRequestT = Model::DescribeTapeRecoveryPointsRequest>
        Model::DescribeTapeRecoveryPointsOutcomeCallable DescribeTapeRecoveryPointsCallable(const DescribeTapeRecoveryPointsRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeTapeRecoveryPoints, request);
        }
 
        template<typename DescribeTapeRecoveryPointsRequestT = Model::DescribeTapeRecoveryPointsRequest>
        void DescribeTapeRecoveryPointsAsync(const DescribeTapeRecoveryPointsRequestT& request, const DescribeTapeRecoveryPointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeTapeRecoveryPoints, request, handler, context);
        }
 
        virtual Model::DescribeTapesOutcome DescribeTapes(const Model::DescribeTapesRequest& request) const;
 
        template<typename DescribeTapesRequestT = Model::DescribeTapesRequest>
        Model::DescribeTapesOutcomeCallable DescribeTapesCallable(const DescribeTapesRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeTapes, request);
        }
 
        template<typename DescribeTapesRequestT = Model::DescribeTapesRequest>
        void DescribeTapesAsync(const DescribeTapesRequestT& request, const DescribeTapesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeTapes, request, handler, context);
        }
 
        virtual Model::DescribeUploadBufferOutcome DescribeUploadBuffer(const Model::DescribeUploadBufferRequest& request) const;
 
        template<typename DescribeUploadBufferRequestT = Model::DescribeUploadBufferRequest>
        Model::DescribeUploadBufferOutcomeCallable DescribeUploadBufferCallable(const DescribeUploadBufferRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeUploadBuffer, request);
        }
 
        template<typename DescribeUploadBufferRequestT = Model::DescribeUploadBufferRequest>
        void DescribeUploadBufferAsync(const DescribeUploadBufferRequestT& request, const DescribeUploadBufferResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeUploadBuffer, request, handler, context);
        }
 
        virtual Model::DescribeVTLDevicesOutcome DescribeVTLDevices(const Model::DescribeVTLDevicesRequest& request) const;
 
        template<typename DescribeVTLDevicesRequestT = Model::DescribeVTLDevicesRequest>
        Model::DescribeVTLDevicesOutcomeCallable DescribeVTLDevicesCallable(const DescribeVTLDevicesRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeVTLDevices, request);
        }
 
        template<typename DescribeVTLDevicesRequestT = Model::DescribeVTLDevicesRequest>
        void DescribeVTLDevicesAsync(const DescribeVTLDevicesRequestT& request, const DescribeVTLDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeVTLDevices, request, handler, context);
        }
 
        virtual Model::DescribeWorkingStorageOutcome DescribeWorkingStorage(const Model::DescribeWorkingStorageRequest& request) const;
 
        template<typename DescribeWorkingStorageRequestT = Model::DescribeWorkingStorageRequest>
        Model::DescribeWorkingStorageOutcomeCallable DescribeWorkingStorageCallable(const DescribeWorkingStorageRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DescribeWorkingStorage, request);
        }
 
        template<typename DescribeWorkingStorageRequestT = Model::DescribeWorkingStorageRequest>
        void DescribeWorkingStorageAsync(const DescribeWorkingStorageRequestT& request, const DescribeWorkingStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DescribeWorkingStorage, request, handler, context);
        }
 
        virtual Model::DetachVolumeOutcome DetachVolume(const Model::DetachVolumeRequest& request) const;
 
        template<typename DetachVolumeRequestT = Model::DetachVolumeRequest>
        Model::DetachVolumeOutcomeCallable DetachVolumeCallable(const DetachVolumeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DetachVolume, request);
        }
 
        template<typename DetachVolumeRequestT = Model::DetachVolumeRequest>
        void DetachVolumeAsync(const DetachVolumeRequestT& request, const DetachVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DetachVolume, request, handler, context);
        }
 
        virtual Model::DisableGatewayOutcome DisableGateway(const Model::DisableGatewayRequest& request) const;
 
        template<typename DisableGatewayRequestT = Model::DisableGatewayRequest>
        Model::DisableGatewayOutcomeCallable DisableGatewayCallable(const DisableGatewayRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DisableGateway, request);
        }
 
        template<typename DisableGatewayRequestT = Model::DisableGatewayRequest>
        void DisableGatewayAsync(const DisableGatewayRequestT& request, const DisableGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DisableGateway, request, handler, context);
        }
 
        virtual Model::DisassociateFileSystemOutcome DisassociateFileSystem(const Model::DisassociateFileSystemRequest& request) const;
 
        template<typename DisassociateFileSystemRequestT = Model::DisassociateFileSystemRequest>
        Model::DisassociateFileSystemOutcomeCallable DisassociateFileSystemCallable(const DisassociateFileSystemRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::DisassociateFileSystem, request);
        }
 
        template<typename DisassociateFileSystemRequestT = Model::DisassociateFileSystemRequest>
        void DisassociateFileSystemAsync(const DisassociateFileSystemRequestT& request, const DisassociateFileSystemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::DisassociateFileSystem, request, handler, context);
        }
 
        virtual Model::JoinDomainOutcome JoinDomain(const Model::JoinDomainRequest& request) const;
 
        template<typename JoinDomainRequestT = Model::JoinDomainRequest>
        Model::JoinDomainOutcomeCallable JoinDomainCallable(const JoinDomainRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::JoinDomain, request);
        }
 
        template<typename JoinDomainRequestT = Model::JoinDomainRequest>
        void JoinDomainAsync(const JoinDomainRequestT& request, const JoinDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::JoinDomain, request, handler, context);
        }
 
        virtual Model::ListAutomaticTapeCreationPoliciesOutcome ListAutomaticTapeCreationPolicies(const Model::ListAutomaticTapeCreationPoliciesRequest& request = {}) const;
 
        template<typename ListAutomaticTapeCreationPoliciesRequestT = Model::ListAutomaticTapeCreationPoliciesRequest>
        Model::ListAutomaticTapeCreationPoliciesOutcomeCallable ListAutomaticTapeCreationPoliciesCallable(const ListAutomaticTapeCreationPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&StorageGatewayClient::ListAutomaticTapeCreationPolicies, request);
        }
 
        template<typename ListAutomaticTapeCreationPoliciesRequestT = Model::ListAutomaticTapeCreationPoliciesRequest>
        void ListAutomaticTapeCreationPoliciesAsync(const ListAutomaticTapeCreationPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAutomaticTapeCreationPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&StorageGatewayClient::ListAutomaticTapeCreationPolicies, request, handler, context);
        }
 
        virtual Model::ListFileSharesOutcome ListFileShares(const Model::ListFileSharesRequest& request = {}) const;
 
        template<typename ListFileSharesRequestT = Model::ListFileSharesRequest>
        Model::ListFileSharesOutcomeCallable ListFileSharesCallable(const ListFileSharesRequestT& request = {}) const
        {
            return SubmitCallable(&StorageGatewayClient::ListFileShares, request);
        }
 
        template<typename ListFileSharesRequestT = Model::ListFileSharesRequest>
        void ListFileSharesAsync(const ListFileSharesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFileSharesRequestT& request = {}) const
        {
            return SubmitAsync(&StorageGatewayClient::ListFileShares, request, handler, context);
        }
 
        virtual Model::ListFileSystemAssociationsOutcome ListFileSystemAssociations(const Model::ListFileSystemAssociationsRequest& request = {}) const;
 
        template<typename ListFileSystemAssociationsRequestT = Model::ListFileSystemAssociationsRequest>
        Model::ListFileSystemAssociationsOutcomeCallable ListFileSystemAssociationsCallable(const ListFileSystemAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&StorageGatewayClient::ListFileSystemAssociations, request);
        }
 
        template<typename ListFileSystemAssociationsRequestT = Model::ListFileSystemAssociationsRequest>
        void ListFileSystemAssociationsAsync(const ListFileSystemAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFileSystemAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&StorageGatewayClient::ListFileSystemAssociations, request, handler, context);
        }
 
        virtual Model::ListGatewaysOutcome ListGateways(const Model::ListGatewaysRequest& request = {}) const;
 
        template<typename ListGatewaysRequestT = Model::ListGatewaysRequest>
        Model::ListGatewaysOutcomeCallable ListGatewaysCallable(const ListGatewaysRequestT& request = {}) const
        {
            return SubmitCallable(&StorageGatewayClient::ListGateways, request);
        }
 
        template<typename ListGatewaysRequestT = Model::ListGatewaysRequest>
        void ListGatewaysAsync(const ListGatewaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGatewaysRequestT& request = {}) const
        {
            return SubmitAsync(&StorageGatewayClient::ListGateways, request, handler, context);
        }
 
        virtual Model::ListLocalDisksOutcome ListLocalDisks(const Model::ListLocalDisksRequest& request) const;
 
        template<typename ListLocalDisksRequestT = Model::ListLocalDisksRequest>
        Model::ListLocalDisksOutcomeCallable ListLocalDisksCallable(const ListLocalDisksRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::ListLocalDisks, request);
        }
 
        template<typename ListLocalDisksRequestT = Model::ListLocalDisksRequest>
        void ListLocalDisksAsync(const ListLocalDisksRequestT& request, const ListLocalDisksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::ListLocalDisks, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTapePoolsOutcome ListTapePools(const Model::ListTapePoolsRequest& request = {}) const;
 
        template<typename ListTapePoolsRequestT = Model::ListTapePoolsRequest>
        Model::ListTapePoolsOutcomeCallable ListTapePoolsCallable(const ListTapePoolsRequestT& request = {}) const
        {
            return SubmitCallable(&StorageGatewayClient::ListTapePools, request);
        }
 
        template<typename ListTapePoolsRequestT = Model::ListTapePoolsRequest>
        void ListTapePoolsAsync(const ListTapePoolsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTapePoolsRequestT& request = {}) const
        {
            return SubmitAsync(&StorageGatewayClient::ListTapePools, request, handler, context);
        }
 
        virtual Model::ListTapesOutcome ListTapes(const Model::ListTapesRequest& request = {}) const;
 
        template<typename ListTapesRequestT = Model::ListTapesRequest>
        Model::ListTapesOutcomeCallable ListTapesCallable(const ListTapesRequestT& request = {}) const
        {
            return SubmitCallable(&StorageGatewayClient::ListTapes, request);
        }
 
        template<typename ListTapesRequestT = Model::ListTapesRequest>
        void ListTapesAsync(const ListTapesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTapesRequestT& request = {}) const
        {
            return SubmitAsync(&StorageGatewayClient::ListTapes, request, handler, context);
        }
 
        virtual Model::ListVolumeInitiatorsOutcome ListVolumeInitiators(const Model::ListVolumeInitiatorsRequest& request) const;
 
        template<typename ListVolumeInitiatorsRequestT = Model::ListVolumeInitiatorsRequest>
        Model::ListVolumeInitiatorsOutcomeCallable ListVolumeInitiatorsCallable(const ListVolumeInitiatorsRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::ListVolumeInitiators, request);
        }
 
        template<typename ListVolumeInitiatorsRequestT = Model::ListVolumeInitiatorsRequest>
        void ListVolumeInitiatorsAsync(const ListVolumeInitiatorsRequestT& request, const ListVolumeInitiatorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::ListVolumeInitiators, request, handler, context);
        }
 
        virtual Model::ListVolumeRecoveryPointsOutcome ListVolumeRecoveryPoints(const Model::ListVolumeRecoveryPointsRequest& request) const;
 
        template<typename ListVolumeRecoveryPointsRequestT = Model::ListVolumeRecoveryPointsRequest>
        Model::ListVolumeRecoveryPointsOutcomeCallable ListVolumeRecoveryPointsCallable(const ListVolumeRecoveryPointsRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::ListVolumeRecoveryPoints, request);
        }
 
        template<typename ListVolumeRecoveryPointsRequestT = Model::ListVolumeRecoveryPointsRequest>
        void ListVolumeRecoveryPointsAsync(const ListVolumeRecoveryPointsRequestT& request, const ListVolumeRecoveryPointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::ListVolumeRecoveryPoints, request, handler, context);
        }
 
        virtual Model::ListVolumesOutcome ListVolumes(const Model::ListVolumesRequest& request = {}) const;
 
        template<typename ListVolumesRequestT = Model::ListVolumesRequest>
        Model::ListVolumesOutcomeCallable ListVolumesCallable(const ListVolumesRequestT& request = {}) const
        {
            return SubmitCallable(&StorageGatewayClient::ListVolumes, request);
        }
 
        template<typename ListVolumesRequestT = Model::ListVolumesRequest>
        void ListVolumesAsync(const ListVolumesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVolumesRequestT& request = {}) const
        {
            return SubmitAsync(&StorageGatewayClient::ListVolumes, request, handler, context);
        }
 
        virtual Model::NotifyWhenUploadedOutcome NotifyWhenUploaded(const Model::NotifyWhenUploadedRequest& request) const;
 
        template<typename NotifyWhenUploadedRequestT = Model::NotifyWhenUploadedRequest>
        Model::NotifyWhenUploadedOutcomeCallable NotifyWhenUploadedCallable(const NotifyWhenUploadedRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::NotifyWhenUploaded, request);
        }
 
        template<typename NotifyWhenUploadedRequestT = Model::NotifyWhenUploadedRequest>
        void NotifyWhenUploadedAsync(const NotifyWhenUploadedRequestT& request, const NotifyWhenUploadedResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::NotifyWhenUploaded, request, handler, context);
        }
 
        virtual Model::RefreshCacheOutcome RefreshCache(const Model::RefreshCacheRequest& request) const;
 
        template<typename RefreshCacheRequestT = Model::RefreshCacheRequest>
        Model::RefreshCacheOutcomeCallable RefreshCacheCallable(const RefreshCacheRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::RefreshCache, request);
        }
 
        template<typename RefreshCacheRequestT = Model::RefreshCacheRequest>
        void RefreshCacheAsync(const RefreshCacheRequestT& request, const RefreshCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::RefreshCache, request, handler, context);
        }
 
        virtual Model::RemoveTagsFromResourceOutcome RemoveTagsFromResource(const Model::RemoveTagsFromResourceRequest& request) const;
 
        template<typename RemoveTagsFromResourceRequestT = Model::RemoveTagsFromResourceRequest>
        Model::RemoveTagsFromResourceOutcomeCallable RemoveTagsFromResourceCallable(const RemoveTagsFromResourceRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::RemoveTagsFromResource, request);
        }
 
        template<typename RemoveTagsFromResourceRequestT = Model::RemoveTagsFromResourceRequest>
        void RemoveTagsFromResourceAsync(const RemoveTagsFromResourceRequestT& request, const RemoveTagsFromResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::RemoveTagsFromResource, request, handler, context);
        }
 
        virtual Model::ResetCacheOutcome ResetCache(const Model::ResetCacheRequest& request) const;
 
        template<typename ResetCacheRequestT = Model::ResetCacheRequest>
        Model::ResetCacheOutcomeCallable ResetCacheCallable(const ResetCacheRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::ResetCache, request);
        }
 
        template<typename ResetCacheRequestT = Model::ResetCacheRequest>
        void ResetCacheAsync(const ResetCacheRequestT& request, const ResetCacheResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::ResetCache, request, handler, context);
        }
 
        virtual Model::RetrieveTapeArchiveOutcome RetrieveTapeArchive(const Model::RetrieveTapeArchiveRequest& request) const;
 
        template<typename RetrieveTapeArchiveRequestT = Model::RetrieveTapeArchiveRequest>
        Model::RetrieveTapeArchiveOutcomeCallable RetrieveTapeArchiveCallable(const RetrieveTapeArchiveRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::RetrieveTapeArchive, request);
        }
 
        template<typename RetrieveTapeArchiveRequestT = Model::RetrieveTapeArchiveRequest>
        void RetrieveTapeArchiveAsync(const RetrieveTapeArchiveRequestT& request, const RetrieveTapeArchiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::RetrieveTapeArchive, request, handler, context);
        }
 
        virtual Model::RetrieveTapeRecoveryPointOutcome RetrieveTapeRecoveryPoint(const Model::RetrieveTapeRecoveryPointRequest& request) const;
 
        template<typename RetrieveTapeRecoveryPointRequestT = Model::RetrieveTapeRecoveryPointRequest>
        Model::RetrieveTapeRecoveryPointOutcomeCallable RetrieveTapeRecoveryPointCallable(const RetrieveTapeRecoveryPointRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::RetrieveTapeRecoveryPoint, request);
        }
 
        template<typename RetrieveTapeRecoveryPointRequestT = Model::RetrieveTapeRecoveryPointRequest>
        void RetrieveTapeRecoveryPointAsync(const RetrieveTapeRecoveryPointRequestT& request, const RetrieveTapeRecoveryPointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::RetrieveTapeRecoveryPoint, request, handler, context);
        }
 
        virtual Model::SetLocalConsolePasswordOutcome SetLocalConsolePassword(const Model::SetLocalConsolePasswordRequest& request) const;
 
        template<typename SetLocalConsolePasswordRequestT = Model::SetLocalConsolePasswordRequest>
        Model::SetLocalConsolePasswordOutcomeCallable SetLocalConsolePasswordCallable(const SetLocalConsolePasswordRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::SetLocalConsolePassword, request);
        }
 
        template<typename SetLocalConsolePasswordRequestT = Model::SetLocalConsolePasswordRequest>
        void SetLocalConsolePasswordAsync(const SetLocalConsolePasswordRequestT& request, const SetLocalConsolePasswordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::SetLocalConsolePassword, request, handler, context);
        }
 
        virtual Model::SetSMBGuestPasswordOutcome SetSMBGuestPassword(const Model::SetSMBGuestPasswordRequest& request) const;
 
        template<typename SetSMBGuestPasswordRequestT = Model::SetSMBGuestPasswordRequest>
        Model::SetSMBGuestPasswordOutcomeCallable SetSMBGuestPasswordCallable(const SetSMBGuestPasswordRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::SetSMBGuestPassword, request);
        }
 
        template<typename SetSMBGuestPasswordRequestT = Model::SetSMBGuestPasswordRequest>
        void SetSMBGuestPasswordAsync(const SetSMBGuestPasswordRequestT& request, const SetSMBGuestPasswordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::SetSMBGuestPassword, request, handler, context);
        }
 
        virtual Model::ShutdownGatewayOutcome ShutdownGateway(const Model::ShutdownGatewayRequest& request) const;
 
        template<typename ShutdownGatewayRequestT = Model::ShutdownGatewayRequest>
        Model::ShutdownGatewayOutcomeCallable ShutdownGatewayCallable(const ShutdownGatewayRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::ShutdownGateway, request);
        }
 
        template<typename ShutdownGatewayRequestT = Model::ShutdownGatewayRequest>
        void ShutdownGatewayAsync(const ShutdownGatewayRequestT& request, const ShutdownGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::ShutdownGateway, request, handler, context);
        }
 
        virtual Model::StartAvailabilityMonitorTestOutcome StartAvailabilityMonitorTest(const Model::StartAvailabilityMonitorTestRequest& request) const;
 
        template<typename StartAvailabilityMonitorTestRequestT = Model::StartAvailabilityMonitorTestRequest>
        Model::StartAvailabilityMonitorTestOutcomeCallable StartAvailabilityMonitorTestCallable(const StartAvailabilityMonitorTestRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::StartAvailabilityMonitorTest, request);
        }
 
        template<typename StartAvailabilityMonitorTestRequestT = Model::StartAvailabilityMonitorTestRequest>
        void StartAvailabilityMonitorTestAsync(const StartAvailabilityMonitorTestRequestT& request, const StartAvailabilityMonitorTestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::StartAvailabilityMonitorTest, request, handler, context);
        }
 
        virtual Model::StartGatewayOutcome StartGateway(const Model::StartGatewayRequest& request) const;
 
        template<typename StartGatewayRequestT = Model::StartGatewayRequest>
        Model::StartGatewayOutcomeCallable StartGatewayCallable(const StartGatewayRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::StartGateway, request);
        }
 
        template<typename StartGatewayRequestT = Model::StartGatewayRequest>
        void StartGatewayAsync(const StartGatewayRequestT& request, const StartGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::StartGateway, request, handler, context);
        }
 
        virtual Model::UpdateAutomaticTapeCreationPolicyOutcome UpdateAutomaticTapeCreationPolicy(const Model::UpdateAutomaticTapeCreationPolicyRequest& request) const;
 
        template<typename UpdateAutomaticTapeCreationPolicyRequestT = Model::UpdateAutomaticTapeCreationPolicyRequest>
        Model::UpdateAutomaticTapeCreationPolicyOutcomeCallable UpdateAutomaticTapeCreationPolicyCallable(const UpdateAutomaticTapeCreationPolicyRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateAutomaticTapeCreationPolicy, request);
        }
 
        template<typename UpdateAutomaticTapeCreationPolicyRequestT = Model::UpdateAutomaticTapeCreationPolicyRequest>
        void UpdateAutomaticTapeCreationPolicyAsync(const UpdateAutomaticTapeCreationPolicyRequestT& request, const UpdateAutomaticTapeCreationPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateAutomaticTapeCreationPolicy, request, handler, context);
        }
 
        virtual Model::UpdateBandwidthRateLimitOutcome UpdateBandwidthRateLimit(const Model::UpdateBandwidthRateLimitRequest& request) const;
 
        template<typename UpdateBandwidthRateLimitRequestT = Model::UpdateBandwidthRateLimitRequest>
        Model::UpdateBandwidthRateLimitOutcomeCallable UpdateBandwidthRateLimitCallable(const UpdateBandwidthRateLimitRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateBandwidthRateLimit, request);
        }
 
        template<typename UpdateBandwidthRateLimitRequestT = Model::UpdateBandwidthRateLimitRequest>
        void UpdateBandwidthRateLimitAsync(const UpdateBandwidthRateLimitRequestT& request, const UpdateBandwidthRateLimitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateBandwidthRateLimit, request, handler, context);
        }
 
        virtual Model::UpdateBandwidthRateLimitScheduleOutcome UpdateBandwidthRateLimitSchedule(const Model::UpdateBandwidthRateLimitScheduleRequest& request) const;
 
        template<typename UpdateBandwidthRateLimitScheduleRequestT = Model::UpdateBandwidthRateLimitScheduleRequest>
        Model::UpdateBandwidthRateLimitScheduleOutcomeCallable UpdateBandwidthRateLimitScheduleCallable(const UpdateBandwidthRateLimitScheduleRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateBandwidthRateLimitSchedule, request);
        }
 
        template<typename UpdateBandwidthRateLimitScheduleRequestT = Model::UpdateBandwidthRateLimitScheduleRequest>
        void UpdateBandwidthRateLimitScheduleAsync(const UpdateBandwidthRateLimitScheduleRequestT& request, const UpdateBandwidthRateLimitScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateBandwidthRateLimitSchedule, request, handler, context);
        }
 
        virtual Model::UpdateChapCredentialsOutcome UpdateChapCredentials(const Model::UpdateChapCredentialsRequest& request) const;
 
        template<typename UpdateChapCredentialsRequestT = Model::UpdateChapCredentialsRequest>
        Model::UpdateChapCredentialsOutcomeCallable UpdateChapCredentialsCallable(const UpdateChapCredentialsRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateChapCredentials, request);
        }
 
        template<typename UpdateChapCredentialsRequestT = Model::UpdateChapCredentialsRequest>
        void UpdateChapCredentialsAsync(const UpdateChapCredentialsRequestT& request, const UpdateChapCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateChapCredentials, request, handler, context);
        }
 
        virtual Model::UpdateFileSystemAssociationOutcome UpdateFileSystemAssociation(const Model::UpdateFileSystemAssociationRequest& request) const;
 
        template<typename UpdateFileSystemAssociationRequestT = Model::UpdateFileSystemAssociationRequest>
        Model::UpdateFileSystemAssociationOutcomeCallable UpdateFileSystemAssociationCallable(const UpdateFileSystemAssociationRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateFileSystemAssociation, request);
        }
 
        template<typename UpdateFileSystemAssociationRequestT = Model::UpdateFileSystemAssociationRequest>
        void UpdateFileSystemAssociationAsync(const UpdateFileSystemAssociationRequestT& request, const UpdateFileSystemAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateFileSystemAssociation, request, handler, context);
        }
 
        virtual Model::UpdateGatewayInformationOutcome UpdateGatewayInformation(const Model::UpdateGatewayInformationRequest& request) const;
 
        template<typename UpdateGatewayInformationRequestT = Model::UpdateGatewayInformationRequest>
        Model::UpdateGatewayInformationOutcomeCallable UpdateGatewayInformationCallable(const UpdateGatewayInformationRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateGatewayInformation, request);
        }
 
        template<typename UpdateGatewayInformationRequestT = Model::UpdateGatewayInformationRequest>
        void UpdateGatewayInformationAsync(const UpdateGatewayInformationRequestT& request, const UpdateGatewayInformationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateGatewayInformation, request, handler, context);
        }
 
        virtual Model::UpdateGatewaySoftwareNowOutcome UpdateGatewaySoftwareNow(const Model::UpdateGatewaySoftwareNowRequest& request) const;
 
        template<typename UpdateGatewaySoftwareNowRequestT = Model::UpdateGatewaySoftwareNowRequest>
        Model::UpdateGatewaySoftwareNowOutcomeCallable UpdateGatewaySoftwareNowCallable(const UpdateGatewaySoftwareNowRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateGatewaySoftwareNow, request);
        }
 
        template<typename UpdateGatewaySoftwareNowRequestT = Model::UpdateGatewaySoftwareNowRequest>
        void UpdateGatewaySoftwareNowAsync(const UpdateGatewaySoftwareNowRequestT& request, const UpdateGatewaySoftwareNowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateGatewaySoftwareNow, request, handler, context);
        }
 
        virtual Model::UpdateMaintenanceStartTimeOutcome UpdateMaintenanceStartTime(const Model::UpdateMaintenanceStartTimeRequest& request) const;
 
        template<typename UpdateMaintenanceStartTimeRequestT = Model::UpdateMaintenanceStartTimeRequest>
        Model::UpdateMaintenanceStartTimeOutcomeCallable UpdateMaintenanceStartTimeCallable(const UpdateMaintenanceStartTimeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateMaintenanceStartTime, request);
        }
 
        template<typename UpdateMaintenanceStartTimeRequestT = Model::UpdateMaintenanceStartTimeRequest>
        void UpdateMaintenanceStartTimeAsync(const UpdateMaintenanceStartTimeRequestT& request, const UpdateMaintenanceStartTimeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateMaintenanceStartTime, request, handler, context);
        }
 
        virtual Model::UpdateNFSFileShareOutcome UpdateNFSFileShare(const Model::UpdateNFSFileShareRequest& request) const;
 
        template<typename UpdateNFSFileShareRequestT = Model::UpdateNFSFileShareRequest>
        Model::UpdateNFSFileShareOutcomeCallable UpdateNFSFileShareCallable(const UpdateNFSFileShareRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateNFSFileShare, request);
        }
 
        template<typename UpdateNFSFileShareRequestT = Model::UpdateNFSFileShareRequest>
        void UpdateNFSFileShareAsync(const UpdateNFSFileShareRequestT& request, const UpdateNFSFileShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateNFSFileShare, request, handler, context);
        }
 
        virtual Model::UpdateSMBFileShareOutcome UpdateSMBFileShare(const Model::UpdateSMBFileShareRequest& request) const;
 
        template<typename UpdateSMBFileShareRequestT = Model::UpdateSMBFileShareRequest>
        Model::UpdateSMBFileShareOutcomeCallable UpdateSMBFileShareCallable(const UpdateSMBFileShareRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateSMBFileShare, request);
        }
 
        template<typename UpdateSMBFileShareRequestT = Model::UpdateSMBFileShareRequest>
        void UpdateSMBFileShareAsync(const UpdateSMBFileShareRequestT& request, const UpdateSMBFileShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateSMBFileShare, request, handler, context);
        }
 
        virtual Model::UpdateSMBFileShareVisibilityOutcome UpdateSMBFileShareVisibility(const Model::UpdateSMBFileShareVisibilityRequest& request) const;
 
        template<typename UpdateSMBFileShareVisibilityRequestT = Model::UpdateSMBFileShareVisibilityRequest>
        Model::UpdateSMBFileShareVisibilityOutcomeCallable UpdateSMBFileShareVisibilityCallable(const UpdateSMBFileShareVisibilityRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateSMBFileShareVisibility, request);
        }
 
        template<typename UpdateSMBFileShareVisibilityRequestT = Model::UpdateSMBFileShareVisibilityRequest>
        void UpdateSMBFileShareVisibilityAsync(const UpdateSMBFileShareVisibilityRequestT& request, const UpdateSMBFileShareVisibilityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateSMBFileShareVisibility, request, handler, context);
        }
 
        virtual Model::UpdateSMBLocalGroupsOutcome UpdateSMBLocalGroups(const Model::UpdateSMBLocalGroupsRequest& request) const;
 
        template<typename UpdateSMBLocalGroupsRequestT = Model::UpdateSMBLocalGroupsRequest>
        Model::UpdateSMBLocalGroupsOutcomeCallable UpdateSMBLocalGroupsCallable(const UpdateSMBLocalGroupsRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateSMBLocalGroups, request);
        }
 
        template<typename UpdateSMBLocalGroupsRequestT = Model::UpdateSMBLocalGroupsRequest>
        void UpdateSMBLocalGroupsAsync(const UpdateSMBLocalGroupsRequestT& request, const UpdateSMBLocalGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateSMBLocalGroups, request, handler, context);
        }
 
        virtual Model::UpdateSMBSecurityStrategyOutcome UpdateSMBSecurityStrategy(const Model::UpdateSMBSecurityStrategyRequest& request) const;
 
        template<typename UpdateSMBSecurityStrategyRequestT = Model::UpdateSMBSecurityStrategyRequest>
        Model::UpdateSMBSecurityStrategyOutcomeCallable UpdateSMBSecurityStrategyCallable(const UpdateSMBSecurityStrategyRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateSMBSecurityStrategy, request);
        }
 
        template<typename UpdateSMBSecurityStrategyRequestT = Model::UpdateSMBSecurityStrategyRequest>
        void UpdateSMBSecurityStrategyAsync(const UpdateSMBSecurityStrategyRequestT& request, const UpdateSMBSecurityStrategyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateSMBSecurityStrategy, request, handler, context);
        }
 
        virtual Model::UpdateSnapshotScheduleOutcome UpdateSnapshotSchedule(const Model::UpdateSnapshotScheduleRequest& request) const;
 
        template<typename UpdateSnapshotScheduleRequestT = Model::UpdateSnapshotScheduleRequest>
        Model::UpdateSnapshotScheduleOutcomeCallable UpdateSnapshotScheduleCallable(const UpdateSnapshotScheduleRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateSnapshotSchedule, request);
        }
 
        template<typename UpdateSnapshotScheduleRequestT = Model::UpdateSnapshotScheduleRequest>
        void UpdateSnapshotScheduleAsync(const UpdateSnapshotScheduleRequestT& request, const UpdateSnapshotScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateSnapshotSchedule, request, handler, context);
        }
 
        virtual Model::UpdateVTLDeviceTypeOutcome UpdateVTLDeviceType(const Model::UpdateVTLDeviceTypeRequest& request) const;
 
        template<typename UpdateVTLDeviceTypeRequestT = Model::UpdateVTLDeviceTypeRequest>
        Model::UpdateVTLDeviceTypeOutcomeCallable UpdateVTLDeviceTypeCallable(const UpdateVTLDeviceTypeRequestT& request) const
        {
            return SubmitCallable(&StorageGatewayClient::UpdateVTLDeviceType, request);
        }
 
        template<typename UpdateVTLDeviceTypeRequestT = Model::UpdateVTLDeviceTypeRequest>
        void UpdateVTLDeviceTypeAsync(const UpdateVTLDeviceTypeRequestT& request, const UpdateVTLDeviceTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&StorageGatewayClient::UpdateVTLDeviceType, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<StorageGatewayEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<StorageGatewayClient>;
      void init(const StorageGatewayClientConfiguration& clientConfiguration);
 
      StorageGatewayClientConfiguration m_clientConfiguration;
      std::shared_ptr<StorageGatewayEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace StorageGateway
} // namespace Aws