FSxClient.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/fsx/FSxServiceClientModel.h>
#include <aws/fsx/FSx_EXPORTS.h>
 
namespace Aws {
namespace FSx {
class AWS_FSX_API FSxClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<FSxClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef FSxClientConfiguration ClientConfigurationType;
  typedef FSxEndpointProvider EndpointProviderType;
 
  FSxClient(const Aws::FSx::FSxClientConfiguration& clientConfiguration = Aws::FSx::FSxClientConfiguration(),
            std::shared_ptr<FSxEndpointProviderBase> endpointProvider = nullptr);
 
  FSxClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<FSxEndpointProviderBase> endpointProvider = nullptr,
            const Aws::FSx::FSxClientConfiguration& clientConfiguration = Aws::FSx::FSxClientConfiguration());
 
  FSxClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<FSxEndpointProviderBase> endpointProvider = nullptr,
            const Aws::FSx::FSxClientConfiguration& clientConfiguration = Aws::FSx::FSxClientConfiguration());
 
  /* Legacy constructors due deprecation */
  FSxClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  FSxClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  FSxClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~FSxClient();
 
  virtual Model::AssociateFileSystemAliasesOutcome AssociateFileSystemAliases(
      const Model::AssociateFileSystemAliasesRequest& request) const;
 
  template <typename AssociateFileSystemAliasesRequestT = Model::AssociateFileSystemAliasesRequest>
  Model::AssociateFileSystemAliasesOutcomeCallable AssociateFileSystemAliasesCallable(
      const AssociateFileSystemAliasesRequestT& request) const {
    return SubmitCallable(&FSxClient::AssociateFileSystemAliases, request);
  }
 
  template <typename AssociateFileSystemAliasesRequestT = Model::AssociateFileSystemAliasesRequest>
  void AssociateFileSystemAliasesAsync(const AssociateFileSystemAliasesRequestT& request,
                                       const AssociateFileSystemAliasesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::AssociateFileSystemAliases, request, handler, context);
  }
 
  virtual Model::CancelDataRepositoryTaskOutcome CancelDataRepositoryTask(const Model::CancelDataRepositoryTaskRequest& request) const;
 
  template <typename CancelDataRepositoryTaskRequestT = Model::CancelDataRepositoryTaskRequest>
  Model::CancelDataRepositoryTaskOutcomeCallable CancelDataRepositoryTaskCallable(const CancelDataRepositoryTaskRequestT& request) const {
    return SubmitCallable(&FSxClient::CancelDataRepositoryTask, request);
  }
 
  template <typename CancelDataRepositoryTaskRequestT = Model::CancelDataRepositoryTaskRequest>
  void CancelDataRepositoryTaskAsync(const CancelDataRepositoryTaskRequestT& request,
                                     const CancelDataRepositoryTaskResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CancelDataRepositoryTask, request, handler, context);
  }
 
  virtual Model::CopyBackupOutcome CopyBackup(const Model::CopyBackupRequest& request) const;
 
  template <typename CopyBackupRequestT = Model::CopyBackupRequest>
  Model::CopyBackupOutcomeCallable CopyBackupCallable(const CopyBackupRequestT& request) const {
    return SubmitCallable(&FSxClient::CopyBackup, request);
  }
 
  template <typename CopyBackupRequestT = Model::CopyBackupRequest>
  void CopyBackupAsync(const CopyBackupRequestT& request, const CopyBackupResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CopyBackup, request, handler, context);
  }
 
  virtual Model::CopySnapshotAndUpdateVolumeOutcome CopySnapshotAndUpdateVolume(
      const Model::CopySnapshotAndUpdateVolumeRequest& request) const;
 
  template <typename CopySnapshotAndUpdateVolumeRequestT = Model::CopySnapshotAndUpdateVolumeRequest>
  Model::CopySnapshotAndUpdateVolumeOutcomeCallable CopySnapshotAndUpdateVolumeCallable(
      const CopySnapshotAndUpdateVolumeRequestT& request) const {
    return SubmitCallable(&FSxClient::CopySnapshotAndUpdateVolume, request);
  }
 
  template <typename CopySnapshotAndUpdateVolumeRequestT = Model::CopySnapshotAndUpdateVolumeRequest>
  void CopySnapshotAndUpdateVolumeAsync(const CopySnapshotAndUpdateVolumeRequestT& request,
                                        const CopySnapshotAndUpdateVolumeResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CopySnapshotAndUpdateVolume, request, handler, context);
  }
 
  virtual Model::CreateAndAttachS3AccessPointOutcome CreateAndAttachS3AccessPoint(
      const Model::CreateAndAttachS3AccessPointRequest& request) const;
 
  template <typename CreateAndAttachS3AccessPointRequestT = Model::CreateAndAttachS3AccessPointRequest>
  Model::CreateAndAttachS3AccessPointOutcomeCallable CreateAndAttachS3AccessPointCallable(
      const CreateAndAttachS3AccessPointRequestT& request) const {
    return SubmitCallable(&FSxClient::CreateAndAttachS3AccessPoint, request);
  }
 
  template <typename CreateAndAttachS3AccessPointRequestT = Model::CreateAndAttachS3AccessPointRequest>
  void CreateAndAttachS3AccessPointAsync(const CreateAndAttachS3AccessPointRequestT& request,
                                         const CreateAndAttachS3AccessPointResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CreateAndAttachS3AccessPoint, request, handler, context);
  }
 
  virtual Model::CreateBackupOutcome CreateBackup(const Model::CreateBackupRequest& request = {}) const;
 
  template <typename CreateBackupRequestT = Model::CreateBackupRequest>
  Model::CreateBackupOutcomeCallable CreateBackupCallable(const CreateBackupRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::CreateBackup, request);
  }
 
  template <typename CreateBackupRequestT = Model::CreateBackupRequest>
  void CreateBackupAsync(const CreateBackupResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const CreateBackupRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::CreateBackup, request, handler, context);
  }
 
  virtual Model::CreateDataRepositoryAssociationOutcome CreateDataRepositoryAssociation(
      const Model::CreateDataRepositoryAssociationRequest& request) const;
 
  template <typename CreateDataRepositoryAssociationRequestT = Model::CreateDataRepositoryAssociationRequest>
  Model::CreateDataRepositoryAssociationOutcomeCallable CreateDataRepositoryAssociationCallable(
      const CreateDataRepositoryAssociationRequestT& request) const {
    return SubmitCallable(&FSxClient::CreateDataRepositoryAssociation, request);
  }
 
  template <typename CreateDataRepositoryAssociationRequestT = Model::CreateDataRepositoryAssociationRequest>
  void CreateDataRepositoryAssociationAsync(const CreateDataRepositoryAssociationRequestT& request,
                                            const CreateDataRepositoryAssociationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CreateDataRepositoryAssociation, request, handler, context);
  }
 
  virtual Model::CreateDataRepositoryTaskOutcome CreateDataRepositoryTask(const Model::CreateDataRepositoryTaskRequest& request) const;
 
  template <typename CreateDataRepositoryTaskRequestT = Model::CreateDataRepositoryTaskRequest>
  Model::CreateDataRepositoryTaskOutcomeCallable CreateDataRepositoryTaskCallable(const CreateDataRepositoryTaskRequestT& request) const {
    return SubmitCallable(&FSxClient::CreateDataRepositoryTask, request);
  }
 
  template <typename CreateDataRepositoryTaskRequestT = Model::CreateDataRepositoryTaskRequest>
  void CreateDataRepositoryTaskAsync(const CreateDataRepositoryTaskRequestT& request,
                                     const CreateDataRepositoryTaskResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CreateDataRepositoryTask, request, handler, context);
  }
 
  virtual Model::CreateFileCacheOutcome CreateFileCache(const Model::CreateFileCacheRequest& request) const;
 
  template <typename CreateFileCacheRequestT = Model::CreateFileCacheRequest>
  Model::CreateFileCacheOutcomeCallable CreateFileCacheCallable(const CreateFileCacheRequestT& request) const {
    return SubmitCallable(&FSxClient::CreateFileCache, request);
  }
 
  template <typename CreateFileCacheRequestT = Model::CreateFileCacheRequest>
  void CreateFileCacheAsync(const CreateFileCacheRequestT& request, const CreateFileCacheResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CreateFileCache, request, handler, context);
  }
 
  virtual Model::CreateFileSystemOutcome CreateFileSystem(const Model::CreateFileSystemRequest& request) const;
 
  template <typename CreateFileSystemRequestT = Model::CreateFileSystemRequest>
  Model::CreateFileSystemOutcomeCallable CreateFileSystemCallable(const CreateFileSystemRequestT& request) const {
    return SubmitCallable(&FSxClient::CreateFileSystem, request);
  }
 
  template <typename CreateFileSystemRequestT = Model::CreateFileSystemRequest>
  void CreateFileSystemAsync(const CreateFileSystemRequestT& request, const CreateFileSystemResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CreateFileSystem, request, handler, context);
  }
 
  virtual Model::CreateFileSystemFromBackupOutcome CreateFileSystemFromBackup(
      const Model::CreateFileSystemFromBackupRequest& request) const;
 
  template <typename CreateFileSystemFromBackupRequestT = Model::CreateFileSystemFromBackupRequest>
  Model::CreateFileSystemFromBackupOutcomeCallable CreateFileSystemFromBackupCallable(
      const CreateFileSystemFromBackupRequestT& request) const {
    return SubmitCallable(&FSxClient::CreateFileSystemFromBackup, request);
  }
 
  template <typename CreateFileSystemFromBackupRequestT = Model::CreateFileSystemFromBackupRequest>
  void CreateFileSystemFromBackupAsync(const CreateFileSystemFromBackupRequestT& request,
                                       const CreateFileSystemFromBackupResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CreateFileSystemFromBackup, 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(&FSxClient::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(&FSxClient::CreateSnapshot, request, handler, context);
  }
 
  virtual Model::CreateStorageVirtualMachineOutcome CreateStorageVirtualMachine(
      const Model::CreateStorageVirtualMachineRequest& request) const;
 
  template <typename CreateStorageVirtualMachineRequestT = Model::CreateStorageVirtualMachineRequest>
  Model::CreateStorageVirtualMachineOutcomeCallable CreateStorageVirtualMachineCallable(
      const CreateStorageVirtualMachineRequestT& request) const {
    return SubmitCallable(&FSxClient::CreateStorageVirtualMachine, request);
  }
 
  template <typename CreateStorageVirtualMachineRequestT = Model::CreateStorageVirtualMachineRequest>
  void CreateStorageVirtualMachineAsync(const CreateStorageVirtualMachineRequestT& request,
                                        const CreateStorageVirtualMachineResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CreateStorageVirtualMachine, request, handler, context);
  }
 
  virtual Model::CreateVolumeOutcome CreateVolume(const Model::CreateVolumeRequest& request) const;
 
  template <typename CreateVolumeRequestT = Model::CreateVolumeRequest>
  Model::CreateVolumeOutcomeCallable CreateVolumeCallable(const CreateVolumeRequestT& request) const {
    return SubmitCallable(&FSxClient::CreateVolume, request);
  }
 
  template <typename CreateVolumeRequestT = Model::CreateVolumeRequest>
  void CreateVolumeAsync(const CreateVolumeRequestT& request, const CreateVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CreateVolume, request, handler, context);
  }
 
  virtual Model::CreateVolumeFromBackupOutcome CreateVolumeFromBackup(const Model::CreateVolumeFromBackupRequest& request) const;
 
  template <typename CreateVolumeFromBackupRequestT = Model::CreateVolumeFromBackupRequest>
  Model::CreateVolumeFromBackupOutcomeCallable CreateVolumeFromBackupCallable(const CreateVolumeFromBackupRequestT& request) const {
    return SubmitCallable(&FSxClient::CreateVolumeFromBackup, request);
  }
 
  template <typename CreateVolumeFromBackupRequestT = Model::CreateVolumeFromBackupRequest>
  void CreateVolumeFromBackupAsync(const CreateVolumeFromBackupRequestT& request,
                                   const CreateVolumeFromBackupResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::CreateVolumeFromBackup, request, handler, context);
  }
 
  virtual Model::DeleteBackupOutcome DeleteBackup(const Model::DeleteBackupRequest& request) const;
 
  template <typename DeleteBackupRequestT = Model::DeleteBackupRequest>
  Model::DeleteBackupOutcomeCallable DeleteBackupCallable(const DeleteBackupRequestT& request) const {
    return SubmitCallable(&FSxClient::DeleteBackup, request);
  }
 
  template <typename DeleteBackupRequestT = Model::DeleteBackupRequest>
  void DeleteBackupAsync(const DeleteBackupRequestT& request, const DeleteBackupResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::DeleteBackup, request, handler, context);
  }
 
  virtual Model::DeleteDataRepositoryAssociationOutcome DeleteDataRepositoryAssociation(
      const Model::DeleteDataRepositoryAssociationRequest& request) const;
 
  template <typename DeleteDataRepositoryAssociationRequestT = Model::DeleteDataRepositoryAssociationRequest>
  Model::DeleteDataRepositoryAssociationOutcomeCallable DeleteDataRepositoryAssociationCallable(
      const DeleteDataRepositoryAssociationRequestT& request) const {
    return SubmitCallable(&FSxClient::DeleteDataRepositoryAssociation, request);
  }
 
  template <typename DeleteDataRepositoryAssociationRequestT = Model::DeleteDataRepositoryAssociationRequest>
  void DeleteDataRepositoryAssociationAsync(const DeleteDataRepositoryAssociationRequestT& request,
                                            const DeleteDataRepositoryAssociationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::DeleteDataRepositoryAssociation, request, handler, context);
  }
 
  virtual Model::DeleteFileCacheOutcome DeleteFileCache(const Model::DeleteFileCacheRequest& request) const;
 
  template <typename DeleteFileCacheRequestT = Model::DeleteFileCacheRequest>
  Model::DeleteFileCacheOutcomeCallable DeleteFileCacheCallable(const DeleteFileCacheRequestT& request) const {
    return SubmitCallable(&FSxClient::DeleteFileCache, request);
  }
 
  template <typename DeleteFileCacheRequestT = Model::DeleteFileCacheRequest>
  void DeleteFileCacheAsync(const DeleteFileCacheRequestT& request, const DeleteFileCacheResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::DeleteFileCache, request, handler, context);
  }
 
  virtual Model::DeleteFileSystemOutcome DeleteFileSystem(const Model::DeleteFileSystemRequest& request) const;
 
  template <typename DeleteFileSystemRequestT = Model::DeleteFileSystemRequest>
  Model::DeleteFileSystemOutcomeCallable DeleteFileSystemCallable(const DeleteFileSystemRequestT& request) const {
    return SubmitCallable(&FSxClient::DeleteFileSystem, request);
  }
 
  template <typename DeleteFileSystemRequestT = Model::DeleteFileSystemRequest>
  void DeleteFileSystemAsync(const DeleteFileSystemRequestT& request, const DeleteFileSystemResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::DeleteFileSystem, request, handler, context);
  }
 
  virtual Model::DeleteSnapshotOutcome DeleteSnapshot(const Model::DeleteSnapshotRequest& request) const;
 
  template <typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
  Model::DeleteSnapshotOutcomeCallable DeleteSnapshotCallable(const DeleteSnapshotRequestT& request) const {
    return SubmitCallable(&FSxClient::DeleteSnapshot, request);
  }
 
  template <typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
  void DeleteSnapshotAsync(const DeleteSnapshotRequestT& request, const DeleteSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::DeleteSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteStorageVirtualMachineOutcome DeleteStorageVirtualMachine(
      const Model::DeleteStorageVirtualMachineRequest& request) const;
 
  template <typename DeleteStorageVirtualMachineRequestT = Model::DeleteStorageVirtualMachineRequest>
  Model::DeleteStorageVirtualMachineOutcomeCallable DeleteStorageVirtualMachineCallable(
      const DeleteStorageVirtualMachineRequestT& request) const {
    return SubmitCallable(&FSxClient::DeleteStorageVirtualMachine, request);
  }
 
  template <typename DeleteStorageVirtualMachineRequestT = Model::DeleteStorageVirtualMachineRequest>
  void DeleteStorageVirtualMachineAsync(const DeleteStorageVirtualMachineRequestT& request,
                                        const DeleteStorageVirtualMachineResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::DeleteStorageVirtualMachine, 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(&FSxClient::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(&FSxClient::DeleteVolume, request, handler, context);
  }
 
  virtual Model::DescribeBackupsOutcome DescribeBackups(const Model::DescribeBackupsRequest& request = {}) const;
 
  template <typename DescribeBackupsRequestT = Model::DescribeBackupsRequest>
  Model::DescribeBackupsOutcomeCallable DescribeBackupsCallable(const DescribeBackupsRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeBackups, request);
  }
 
  template <typename DescribeBackupsRequestT = Model::DescribeBackupsRequest>
  void DescribeBackupsAsync(const DescribeBackupsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const DescribeBackupsRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeBackups, request, handler, context);
  }
 
  virtual Model::DescribeDataRepositoryAssociationsOutcome DescribeDataRepositoryAssociations(
      const Model::DescribeDataRepositoryAssociationsRequest& request = {}) const;
 
  template <typename DescribeDataRepositoryAssociationsRequestT = Model::DescribeDataRepositoryAssociationsRequest>
  Model::DescribeDataRepositoryAssociationsOutcomeCallable DescribeDataRepositoryAssociationsCallable(
      const DescribeDataRepositoryAssociationsRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeDataRepositoryAssociations, request);
  }
 
  template <typename DescribeDataRepositoryAssociationsRequestT = Model::DescribeDataRepositoryAssociationsRequest>
  void DescribeDataRepositoryAssociationsAsync(const DescribeDataRepositoryAssociationsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeDataRepositoryAssociationsRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeDataRepositoryAssociations, request, handler, context);
  }
 
  virtual Model::DescribeDataRepositoryTasksOutcome DescribeDataRepositoryTasks(
      const Model::DescribeDataRepositoryTasksRequest& request = {}) const;
 
  template <typename DescribeDataRepositoryTasksRequestT = Model::DescribeDataRepositoryTasksRequest>
  Model::DescribeDataRepositoryTasksOutcomeCallable DescribeDataRepositoryTasksCallable(
      const DescribeDataRepositoryTasksRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeDataRepositoryTasks, request);
  }
 
  template <typename DescribeDataRepositoryTasksRequestT = Model::DescribeDataRepositoryTasksRequest>
  void DescribeDataRepositoryTasksAsync(const DescribeDataRepositoryTasksResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeDataRepositoryTasksRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeDataRepositoryTasks, request, handler, context);
  }
 
  virtual Model::DescribeFileCachesOutcome DescribeFileCaches(const Model::DescribeFileCachesRequest& request = {}) const;
 
  template <typename DescribeFileCachesRequestT = Model::DescribeFileCachesRequest>
  Model::DescribeFileCachesOutcomeCallable DescribeFileCachesCallable(const DescribeFileCachesRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeFileCaches, request);
  }
 
  template <typename DescribeFileCachesRequestT = Model::DescribeFileCachesRequest>
  void DescribeFileCachesAsync(const DescribeFileCachesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DescribeFileCachesRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeFileCaches, request, handler, context);
  }
 
  virtual Model::DescribeFileSystemAliasesOutcome DescribeFileSystemAliases(const Model::DescribeFileSystemAliasesRequest& request) const;
 
  template <typename DescribeFileSystemAliasesRequestT = Model::DescribeFileSystemAliasesRequest>
  Model::DescribeFileSystemAliasesOutcomeCallable DescribeFileSystemAliasesCallable(
      const DescribeFileSystemAliasesRequestT& request) const {
    return SubmitCallable(&FSxClient::DescribeFileSystemAliases, request);
  }
 
  template <typename DescribeFileSystemAliasesRequestT = Model::DescribeFileSystemAliasesRequest>
  void DescribeFileSystemAliasesAsync(const DescribeFileSystemAliasesRequestT& request,
                                      const DescribeFileSystemAliasesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::DescribeFileSystemAliases, request, handler, context);
  }
 
  virtual Model::DescribeFileSystemsOutcome DescribeFileSystems(const Model::DescribeFileSystemsRequest& request = {}) const;
 
  template <typename DescribeFileSystemsRequestT = Model::DescribeFileSystemsRequest>
  Model::DescribeFileSystemsOutcomeCallable DescribeFileSystemsCallable(const DescribeFileSystemsRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeFileSystems, request);
  }
 
  template <typename DescribeFileSystemsRequestT = Model::DescribeFileSystemsRequest>
  void DescribeFileSystemsAsync(const DescribeFileSystemsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeFileSystemsRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeFileSystems, request, handler, context);
  }
 
  virtual Model::DescribeS3AccessPointAttachmentsOutcome DescribeS3AccessPointAttachments(
      const Model::DescribeS3AccessPointAttachmentsRequest& request = {}) const;
 
  template <typename DescribeS3AccessPointAttachmentsRequestT = Model::DescribeS3AccessPointAttachmentsRequest>
  Model::DescribeS3AccessPointAttachmentsOutcomeCallable DescribeS3AccessPointAttachmentsCallable(
      const DescribeS3AccessPointAttachmentsRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeS3AccessPointAttachments, request);
  }
 
  template <typename DescribeS3AccessPointAttachmentsRequestT = Model::DescribeS3AccessPointAttachmentsRequest>
  void DescribeS3AccessPointAttachmentsAsync(const DescribeS3AccessPointAttachmentsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DescribeS3AccessPointAttachmentsRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeS3AccessPointAttachments, request, handler, context);
  }
 
  virtual Model::DescribeSharedVpcConfigurationOutcome DescribeSharedVpcConfiguration(
      const Model::DescribeSharedVpcConfigurationRequest& request = {}) const;
 
  template <typename DescribeSharedVpcConfigurationRequestT = Model::DescribeSharedVpcConfigurationRequest>
  Model::DescribeSharedVpcConfigurationOutcomeCallable DescribeSharedVpcConfigurationCallable(
      const DescribeSharedVpcConfigurationRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeSharedVpcConfiguration, request);
  }
 
  template <typename DescribeSharedVpcConfigurationRequestT = Model::DescribeSharedVpcConfigurationRequest>
  void DescribeSharedVpcConfigurationAsync(const DescribeSharedVpcConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeSharedVpcConfigurationRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeSharedVpcConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeSnapshotsOutcome DescribeSnapshots(const Model::DescribeSnapshotsRequest& request = {}) const;
 
  template <typename DescribeSnapshotsRequestT = Model::DescribeSnapshotsRequest>
  Model::DescribeSnapshotsOutcomeCallable DescribeSnapshotsCallable(const DescribeSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeSnapshots, request);
  }
 
  template <typename DescribeSnapshotsRequestT = Model::DescribeSnapshotsRequest>
  void DescribeSnapshotsAsync(const DescribeSnapshotsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeSnapshots, request, handler, context);
  }
 
  virtual Model::DescribeStorageVirtualMachinesOutcome DescribeStorageVirtualMachines(
      const Model::DescribeStorageVirtualMachinesRequest& request = {}) const;
 
  template <typename DescribeStorageVirtualMachinesRequestT = Model::DescribeStorageVirtualMachinesRequest>
  Model::DescribeStorageVirtualMachinesOutcomeCallable DescribeStorageVirtualMachinesCallable(
      const DescribeStorageVirtualMachinesRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeStorageVirtualMachines, request);
  }
 
  template <typename DescribeStorageVirtualMachinesRequestT = Model::DescribeStorageVirtualMachinesRequest>
  void DescribeStorageVirtualMachinesAsync(const DescribeStorageVirtualMachinesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeStorageVirtualMachinesRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeStorageVirtualMachines, request, handler, context);
  }
 
  virtual Model::DescribeVolumesOutcome DescribeVolumes(const Model::DescribeVolumesRequest& request = {}) const;
 
  template <typename DescribeVolumesRequestT = Model::DescribeVolumesRequest>
  Model::DescribeVolumesOutcomeCallable DescribeVolumesCallable(const DescribeVolumesRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::DescribeVolumes, request);
  }
 
  template <typename DescribeVolumesRequestT = Model::DescribeVolumesRequest>
  void DescribeVolumesAsync(const DescribeVolumesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const DescribeVolumesRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::DescribeVolumes, request, handler, context);
  }
 
  virtual Model::DetachAndDeleteS3AccessPointOutcome DetachAndDeleteS3AccessPoint(
      const Model::DetachAndDeleteS3AccessPointRequest& request) const;
 
  template <typename DetachAndDeleteS3AccessPointRequestT = Model::DetachAndDeleteS3AccessPointRequest>
  Model::DetachAndDeleteS3AccessPointOutcomeCallable DetachAndDeleteS3AccessPointCallable(
      const DetachAndDeleteS3AccessPointRequestT& request) const {
    return SubmitCallable(&FSxClient::DetachAndDeleteS3AccessPoint, request);
  }
 
  template <typename DetachAndDeleteS3AccessPointRequestT = Model::DetachAndDeleteS3AccessPointRequest>
  void DetachAndDeleteS3AccessPointAsync(const DetachAndDeleteS3AccessPointRequestT& request,
                                         const DetachAndDeleteS3AccessPointResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::DetachAndDeleteS3AccessPoint, request, handler, context);
  }
 
  virtual Model::DisassociateFileSystemAliasesOutcome DisassociateFileSystemAliases(
      const Model::DisassociateFileSystemAliasesRequest& request) const;
 
  template <typename DisassociateFileSystemAliasesRequestT = Model::DisassociateFileSystemAliasesRequest>
  Model::DisassociateFileSystemAliasesOutcomeCallable DisassociateFileSystemAliasesCallable(
      const DisassociateFileSystemAliasesRequestT& request) const {
    return SubmitCallable(&FSxClient::DisassociateFileSystemAliases, request);
  }
 
  template <typename DisassociateFileSystemAliasesRequestT = Model::DisassociateFileSystemAliasesRequest>
  void DisassociateFileSystemAliasesAsync(const DisassociateFileSystemAliasesRequestT& request,
                                          const DisassociateFileSystemAliasesResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::DisassociateFileSystemAliases, 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(&FSxClient::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(&FSxClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ReleaseFileSystemNfsV3LocksOutcome ReleaseFileSystemNfsV3Locks(
      const Model::ReleaseFileSystemNfsV3LocksRequest& request) const;
 
  template <typename ReleaseFileSystemNfsV3LocksRequestT = Model::ReleaseFileSystemNfsV3LocksRequest>
  Model::ReleaseFileSystemNfsV3LocksOutcomeCallable ReleaseFileSystemNfsV3LocksCallable(
      const ReleaseFileSystemNfsV3LocksRequestT& request) const {
    return SubmitCallable(&FSxClient::ReleaseFileSystemNfsV3Locks, request);
  }
 
  template <typename ReleaseFileSystemNfsV3LocksRequestT = Model::ReleaseFileSystemNfsV3LocksRequest>
  void ReleaseFileSystemNfsV3LocksAsync(const ReleaseFileSystemNfsV3LocksRequestT& request,
                                        const ReleaseFileSystemNfsV3LocksResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::ReleaseFileSystemNfsV3Locks, request, handler, context);
  }
 
  virtual Model::RestoreVolumeFromSnapshotOutcome RestoreVolumeFromSnapshot(const Model::RestoreVolumeFromSnapshotRequest& request) const;
 
  template <typename RestoreVolumeFromSnapshotRequestT = Model::RestoreVolumeFromSnapshotRequest>
  Model::RestoreVolumeFromSnapshotOutcomeCallable RestoreVolumeFromSnapshotCallable(
      const RestoreVolumeFromSnapshotRequestT& request) const {
    return SubmitCallable(&FSxClient::RestoreVolumeFromSnapshot, request);
  }
 
  template <typename RestoreVolumeFromSnapshotRequestT = Model::RestoreVolumeFromSnapshotRequest>
  void RestoreVolumeFromSnapshotAsync(const RestoreVolumeFromSnapshotRequestT& request,
                                      const RestoreVolumeFromSnapshotResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::RestoreVolumeFromSnapshot, request, handler, context);
  }
 
  virtual Model::StartMisconfiguredStateRecoveryOutcome StartMisconfiguredStateRecovery(
      const Model::StartMisconfiguredStateRecoveryRequest& request) const;
 
  template <typename StartMisconfiguredStateRecoveryRequestT = Model::StartMisconfiguredStateRecoveryRequest>
  Model::StartMisconfiguredStateRecoveryOutcomeCallable StartMisconfiguredStateRecoveryCallable(
      const StartMisconfiguredStateRecoveryRequestT& request) const {
    return SubmitCallable(&FSxClient::StartMisconfiguredStateRecovery, request);
  }
 
  template <typename StartMisconfiguredStateRecoveryRequestT = Model::StartMisconfiguredStateRecoveryRequest>
  void StartMisconfiguredStateRecoveryAsync(const StartMisconfiguredStateRecoveryRequestT& request,
                                            const StartMisconfiguredStateRecoveryResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::StartMisconfiguredStateRecovery, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&FSxClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&FSxClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateDataRepositoryAssociationOutcome UpdateDataRepositoryAssociation(
      const Model::UpdateDataRepositoryAssociationRequest& request) const;
 
  template <typename UpdateDataRepositoryAssociationRequestT = Model::UpdateDataRepositoryAssociationRequest>
  Model::UpdateDataRepositoryAssociationOutcomeCallable UpdateDataRepositoryAssociationCallable(
      const UpdateDataRepositoryAssociationRequestT& request) const {
    return SubmitCallable(&FSxClient::UpdateDataRepositoryAssociation, request);
  }
 
  template <typename UpdateDataRepositoryAssociationRequestT = Model::UpdateDataRepositoryAssociationRequest>
  void UpdateDataRepositoryAssociationAsync(const UpdateDataRepositoryAssociationRequestT& request,
                                            const UpdateDataRepositoryAssociationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::UpdateDataRepositoryAssociation, request, handler, context);
  }
 
  virtual Model::UpdateFileCacheOutcome UpdateFileCache(const Model::UpdateFileCacheRequest& request) const;
 
  template <typename UpdateFileCacheRequestT = Model::UpdateFileCacheRequest>
  Model::UpdateFileCacheOutcomeCallable UpdateFileCacheCallable(const UpdateFileCacheRequestT& request) const {
    return SubmitCallable(&FSxClient::UpdateFileCache, request);
  }
 
  template <typename UpdateFileCacheRequestT = Model::UpdateFileCacheRequest>
  void UpdateFileCacheAsync(const UpdateFileCacheRequestT& request, const UpdateFileCacheResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::UpdateFileCache, request, handler, context);
  }
 
  virtual Model::UpdateFileSystemOutcome UpdateFileSystem(const Model::UpdateFileSystemRequest& request) const;
 
  template <typename UpdateFileSystemRequestT = Model::UpdateFileSystemRequest>
  Model::UpdateFileSystemOutcomeCallable UpdateFileSystemCallable(const UpdateFileSystemRequestT& request) const {
    return SubmitCallable(&FSxClient::UpdateFileSystem, request);
  }
 
  template <typename UpdateFileSystemRequestT = Model::UpdateFileSystemRequest>
  void UpdateFileSystemAsync(const UpdateFileSystemRequestT& request, const UpdateFileSystemResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::UpdateFileSystem, request, handler, context);
  }
 
  virtual Model::UpdateSharedVpcConfigurationOutcome UpdateSharedVpcConfiguration(
      const Model::UpdateSharedVpcConfigurationRequest& request = {}) const;
 
  template <typename UpdateSharedVpcConfigurationRequestT = Model::UpdateSharedVpcConfigurationRequest>
  Model::UpdateSharedVpcConfigurationOutcomeCallable UpdateSharedVpcConfigurationCallable(
      const UpdateSharedVpcConfigurationRequestT& request = {}) const {
    return SubmitCallable(&FSxClient::UpdateSharedVpcConfiguration, request);
  }
 
  template <typename UpdateSharedVpcConfigurationRequestT = Model::UpdateSharedVpcConfigurationRequest>
  void UpdateSharedVpcConfigurationAsync(const UpdateSharedVpcConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const UpdateSharedVpcConfigurationRequestT& request = {}) const {
    return SubmitAsync(&FSxClient::UpdateSharedVpcConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateSnapshotOutcome UpdateSnapshot(const Model::UpdateSnapshotRequest& request) const;
 
  template <typename UpdateSnapshotRequestT = Model::UpdateSnapshotRequest>
  Model::UpdateSnapshotOutcomeCallable UpdateSnapshotCallable(const UpdateSnapshotRequestT& request) const {
    return SubmitCallable(&FSxClient::UpdateSnapshot, request);
  }
 
  template <typename UpdateSnapshotRequestT = Model::UpdateSnapshotRequest>
  void UpdateSnapshotAsync(const UpdateSnapshotRequestT& request, const UpdateSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::UpdateSnapshot, request, handler, context);
  }
 
  virtual Model::UpdateStorageVirtualMachineOutcome UpdateStorageVirtualMachine(
      const Model::UpdateStorageVirtualMachineRequest& request) const;
 
  template <typename UpdateStorageVirtualMachineRequestT = Model::UpdateStorageVirtualMachineRequest>
  Model::UpdateStorageVirtualMachineOutcomeCallable UpdateStorageVirtualMachineCallable(
      const UpdateStorageVirtualMachineRequestT& request) const {
    return SubmitCallable(&FSxClient::UpdateStorageVirtualMachine, request);
  }
 
  template <typename UpdateStorageVirtualMachineRequestT = Model::UpdateStorageVirtualMachineRequest>
  void UpdateStorageVirtualMachineAsync(const UpdateStorageVirtualMachineRequestT& request,
                                        const UpdateStorageVirtualMachineResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::UpdateStorageVirtualMachine, request, handler, context);
  }
 
  virtual Model::UpdateVolumeOutcome UpdateVolume(const Model::UpdateVolumeRequest& request) const;
 
  template <typename UpdateVolumeRequestT = Model::UpdateVolumeRequest>
  Model::UpdateVolumeOutcomeCallable UpdateVolumeCallable(const UpdateVolumeRequestT& request) const {
    return SubmitCallable(&FSxClient::UpdateVolume, request);
  }
 
  template <typename UpdateVolumeRequestT = Model::UpdateVolumeRequest>
  void UpdateVolumeAsync(const UpdateVolumeRequestT& request, const UpdateVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FSxClient::UpdateVolume, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<FSxEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<FSxClient>;
  void init(const FSxClientConfiguration& clientConfiguration);
 
  FSxClientConfiguration m_clientConfiguration;
  std::shared_ptr<FSxEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace FSx
}  // namespace Aws