FSxClient.h

 
#pragma once
#include <aws/fsx/FSx_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/fsx/FSxServiceClientModel.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