StorageGatewayClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/storagegateway/StorageGatewayPaginationBase.h>
#include <aws/storagegateway/StorageGatewayServiceClientModel.h>
#include <aws/storagegateway/StorageGatewayWaiter.h>
#include <aws/storagegateway/StorageGateway_EXPORTS.h>
 
namespace Aws {
namespace StorageGateway {
class AWS_STORAGEGATEWAY_API StorageGatewayClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<StorageGatewayClient>,
                                                    public StorageGatewayPaginationBase<StorageGatewayClient>,
                                                    public StorageGatewayWaiter<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::CancelCacheReportOutcome CancelCacheReport(const Model::CancelCacheReportRequest& request) const;
 
  template <typename CancelCacheReportRequestT = Model::CancelCacheReportRequest>
  Model::CancelCacheReportOutcomeCallable CancelCacheReportCallable(const CancelCacheReportRequestT& request) const {
    return SubmitCallable(&StorageGatewayClient::CancelCacheReport, request);
  }
 
  template <typename CancelCacheReportRequestT = Model::CancelCacheReportRequest>
  void CancelCacheReportAsync(const CancelCacheReportRequestT& request, const CancelCacheReportResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&StorageGatewayClient::CancelCacheReport, 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::DeleteCacheReportOutcome DeleteCacheReport(const Model::DeleteCacheReportRequest& request) const;
 
  template <typename DeleteCacheReportRequestT = Model::DeleteCacheReportRequest>
  Model::DeleteCacheReportOutcomeCallable DeleteCacheReportCallable(const DeleteCacheReportRequestT& request) const {
    return SubmitCallable(&StorageGatewayClient::DeleteCacheReport, request);
  }
 
  template <typename DeleteCacheReportRequestT = Model::DeleteCacheReportRequest>
  void DeleteCacheReportAsync(const DeleteCacheReportRequestT& request, const DeleteCacheReportResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&StorageGatewayClient::DeleteCacheReport, 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::DescribeCacheReportOutcome DescribeCacheReport(const Model::DescribeCacheReportRequest& request) const;
 
  template <typename DescribeCacheReportRequestT = Model::DescribeCacheReportRequest>
  Model::DescribeCacheReportOutcomeCallable DescribeCacheReportCallable(const DescribeCacheReportRequestT& request) const {
    return SubmitCallable(&StorageGatewayClient::DescribeCacheReport, request);
  }
 
  template <typename DescribeCacheReportRequestT = Model::DescribeCacheReportRequest>
  void DescribeCacheReportAsync(const DescribeCacheReportRequestT& request, const DescribeCacheReportResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&StorageGatewayClient::DescribeCacheReport, 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::EvictFilesFailingUploadOutcome EvictFilesFailingUpload(const Model::EvictFilesFailingUploadRequest& request) const;
 
  template <typename EvictFilesFailingUploadRequestT = Model::EvictFilesFailingUploadRequest>
  Model::EvictFilesFailingUploadOutcomeCallable EvictFilesFailingUploadCallable(const EvictFilesFailingUploadRequestT& request) const {
    return SubmitCallable(&StorageGatewayClient::EvictFilesFailingUpload, request);
  }
 
  template <typename EvictFilesFailingUploadRequestT = Model::EvictFilesFailingUploadRequest>
  void EvictFilesFailingUploadAsync(const EvictFilesFailingUploadRequestT& request,
                                    const EvictFilesFailingUploadResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&StorageGatewayClient::EvictFilesFailingUpload, 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::ListCacheReportsOutcome ListCacheReports(const Model::ListCacheReportsRequest& request = {}) const;
 
  template <typename ListCacheReportsRequestT = Model::ListCacheReportsRequest>
  Model::ListCacheReportsOutcomeCallable ListCacheReportsCallable(const ListCacheReportsRequestT& request = {}) const {
    return SubmitCallable(&StorageGatewayClient::ListCacheReports, request);
  }
 
  template <typename ListCacheReportsRequestT = Model::ListCacheReportsRequest>
  void ListCacheReportsAsync(const ListCacheReportsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListCacheReportsRequestT& request = {}) const {
    return SubmitAsync(&StorageGatewayClient::ListCacheReports, 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::StartCacheReportOutcome StartCacheReport(const Model::StartCacheReportRequest& request) const;
 
  template <typename StartCacheReportRequestT = Model::StartCacheReportRequest>
  Model::StartCacheReportOutcomeCallable StartCacheReportCallable(const StartCacheReportRequestT& request) const {
    return SubmitCallable(&StorageGatewayClient::StartCacheReport, request);
  }
 
  template <typename StartCacheReportRequestT = Model::StartCacheReportRequest>
  void StartCacheReportAsync(const StartCacheReportRequestT& request, const StartCacheReportResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&StorageGatewayClient::StartCacheReport, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<StorageGatewayEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<StorageGatewayClient>;
  void init(const StorageGatewayClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, StorageGatewayError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  StorageGatewayClientConfiguration m_clientConfiguration;
  std::shared_ptr<StorageGatewayEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace StorageGateway
}  // namespace Aws