DataSyncClient.h

 
#pragma once
#include <aws/datasync/DataSync_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/datasync/DataSyncServiceClientModel.h>
 
namespace Aws
{
namespace DataSync
{
  class AWS_DATASYNC_API DataSyncClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<DataSyncClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef DataSyncClientConfiguration ClientConfigurationType;
      typedef DataSyncEndpointProvider EndpointProviderType;
 
        DataSyncClient(const Aws::DataSync::DataSyncClientConfiguration& clientConfiguration = Aws::DataSync::DataSyncClientConfiguration(),
                       std::shared_ptr<DataSyncEndpointProviderBase> endpointProvider = nullptr);
 
        DataSyncClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<DataSyncEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::DataSync::DataSyncClientConfiguration& clientConfiguration = Aws::DataSync::DataSyncClientConfiguration());
 
        DataSyncClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<DataSyncEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::DataSync::DataSyncClientConfiguration& clientConfiguration = Aws::DataSync::DataSyncClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        DataSyncClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DataSyncClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DataSyncClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~DataSyncClient();
 
        virtual Model::AddStorageSystemOutcome AddStorageSystem(const Model::AddStorageSystemRequest& request) const;
 
        template<typename AddStorageSystemRequestT = Model::AddStorageSystemRequest>
        Model::AddStorageSystemOutcomeCallable AddStorageSystemCallable(const AddStorageSystemRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::AddStorageSystem, request);
        }
 
        template<typename AddStorageSystemRequestT = Model::AddStorageSystemRequest>
        void AddStorageSystemAsync(const AddStorageSystemRequestT& request, const AddStorageSystemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::AddStorageSystem, request, handler, context);
        }
 
        virtual Model::CancelTaskExecutionOutcome CancelTaskExecution(const Model::CancelTaskExecutionRequest& request) const;
 
        template<typename CancelTaskExecutionRequestT = Model::CancelTaskExecutionRequest>
        Model::CancelTaskExecutionOutcomeCallable CancelTaskExecutionCallable(const CancelTaskExecutionRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CancelTaskExecution, request);
        }
 
        template<typename CancelTaskExecutionRequestT = Model::CancelTaskExecutionRequest>
        void CancelTaskExecutionAsync(const CancelTaskExecutionRequestT& request, const CancelTaskExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CancelTaskExecution, request, handler, context);
        }
 
        virtual Model::CreateAgentOutcome CreateAgent(const Model::CreateAgentRequest& request) const;
 
        template<typename CreateAgentRequestT = Model::CreateAgentRequest>
        Model::CreateAgentOutcomeCallable CreateAgentCallable(const CreateAgentRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateAgent, request);
        }
 
        template<typename CreateAgentRequestT = Model::CreateAgentRequest>
        void CreateAgentAsync(const CreateAgentRequestT& request, const CreateAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateAgent, request, handler, context);
        }
 
        virtual Model::CreateLocationAzureBlobOutcome CreateLocationAzureBlob(const Model::CreateLocationAzureBlobRequest& request) const;
 
        template<typename CreateLocationAzureBlobRequestT = Model::CreateLocationAzureBlobRequest>
        Model::CreateLocationAzureBlobOutcomeCallable CreateLocationAzureBlobCallable(const CreateLocationAzureBlobRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationAzureBlob, request);
        }
 
        template<typename CreateLocationAzureBlobRequestT = Model::CreateLocationAzureBlobRequest>
        void CreateLocationAzureBlobAsync(const CreateLocationAzureBlobRequestT& request, const CreateLocationAzureBlobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationAzureBlob, request, handler, context);
        }
 
        virtual Model::CreateLocationEfsOutcome CreateLocationEfs(const Model::CreateLocationEfsRequest& request) const;
 
        template<typename CreateLocationEfsRequestT = Model::CreateLocationEfsRequest>
        Model::CreateLocationEfsOutcomeCallable CreateLocationEfsCallable(const CreateLocationEfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationEfs, request);
        }
 
        template<typename CreateLocationEfsRequestT = Model::CreateLocationEfsRequest>
        void CreateLocationEfsAsync(const CreateLocationEfsRequestT& request, const CreateLocationEfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationEfs, request, handler, context);
        }
 
        virtual Model::CreateLocationFsxLustreOutcome CreateLocationFsxLustre(const Model::CreateLocationFsxLustreRequest& request) const;
 
        template<typename CreateLocationFsxLustreRequestT = Model::CreateLocationFsxLustreRequest>
        Model::CreateLocationFsxLustreOutcomeCallable CreateLocationFsxLustreCallable(const CreateLocationFsxLustreRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationFsxLustre, request);
        }
 
        template<typename CreateLocationFsxLustreRequestT = Model::CreateLocationFsxLustreRequest>
        void CreateLocationFsxLustreAsync(const CreateLocationFsxLustreRequestT& request, const CreateLocationFsxLustreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationFsxLustre, request, handler, context);
        }
 
        virtual Model::CreateLocationFsxOntapOutcome CreateLocationFsxOntap(const Model::CreateLocationFsxOntapRequest& request) const;
 
        template<typename CreateLocationFsxOntapRequestT = Model::CreateLocationFsxOntapRequest>
        Model::CreateLocationFsxOntapOutcomeCallable CreateLocationFsxOntapCallable(const CreateLocationFsxOntapRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationFsxOntap, request);
        }
 
        template<typename CreateLocationFsxOntapRequestT = Model::CreateLocationFsxOntapRequest>
        void CreateLocationFsxOntapAsync(const CreateLocationFsxOntapRequestT& request, const CreateLocationFsxOntapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationFsxOntap, request, handler, context);
        }
 
        virtual Model::CreateLocationFsxOpenZfsOutcome CreateLocationFsxOpenZfs(const Model::CreateLocationFsxOpenZfsRequest& request) const;
 
        template<typename CreateLocationFsxOpenZfsRequestT = Model::CreateLocationFsxOpenZfsRequest>
        Model::CreateLocationFsxOpenZfsOutcomeCallable CreateLocationFsxOpenZfsCallable(const CreateLocationFsxOpenZfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationFsxOpenZfs, request);
        }
 
        template<typename CreateLocationFsxOpenZfsRequestT = Model::CreateLocationFsxOpenZfsRequest>
        void CreateLocationFsxOpenZfsAsync(const CreateLocationFsxOpenZfsRequestT& request, const CreateLocationFsxOpenZfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationFsxOpenZfs, request, handler, context);
        }
 
        virtual Model::CreateLocationFsxWindowsOutcome CreateLocationFsxWindows(const Model::CreateLocationFsxWindowsRequest& request) const;
 
        template<typename CreateLocationFsxWindowsRequestT = Model::CreateLocationFsxWindowsRequest>
        Model::CreateLocationFsxWindowsOutcomeCallable CreateLocationFsxWindowsCallable(const CreateLocationFsxWindowsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationFsxWindows, request);
        }
 
        template<typename CreateLocationFsxWindowsRequestT = Model::CreateLocationFsxWindowsRequest>
        void CreateLocationFsxWindowsAsync(const CreateLocationFsxWindowsRequestT& request, const CreateLocationFsxWindowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationFsxWindows, request, handler, context);
        }
 
        virtual Model::CreateLocationHdfsOutcome CreateLocationHdfs(const Model::CreateLocationHdfsRequest& request) const;
 
        template<typename CreateLocationHdfsRequestT = Model::CreateLocationHdfsRequest>
        Model::CreateLocationHdfsOutcomeCallable CreateLocationHdfsCallable(const CreateLocationHdfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationHdfs, request);
        }
 
        template<typename CreateLocationHdfsRequestT = Model::CreateLocationHdfsRequest>
        void CreateLocationHdfsAsync(const CreateLocationHdfsRequestT& request, const CreateLocationHdfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationHdfs, request, handler, context);
        }
 
        virtual Model::CreateLocationNfsOutcome CreateLocationNfs(const Model::CreateLocationNfsRequest& request) const;
 
        template<typename CreateLocationNfsRequestT = Model::CreateLocationNfsRequest>
        Model::CreateLocationNfsOutcomeCallable CreateLocationNfsCallable(const CreateLocationNfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationNfs, request);
        }
 
        template<typename CreateLocationNfsRequestT = Model::CreateLocationNfsRequest>
        void CreateLocationNfsAsync(const CreateLocationNfsRequestT& request, const CreateLocationNfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationNfs, request, handler, context);
        }
 
        virtual Model::CreateLocationObjectStorageOutcome CreateLocationObjectStorage(const Model::CreateLocationObjectStorageRequest& request) const;
 
        template<typename CreateLocationObjectStorageRequestT = Model::CreateLocationObjectStorageRequest>
        Model::CreateLocationObjectStorageOutcomeCallable CreateLocationObjectStorageCallable(const CreateLocationObjectStorageRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationObjectStorage, request);
        }
 
        template<typename CreateLocationObjectStorageRequestT = Model::CreateLocationObjectStorageRequest>
        void CreateLocationObjectStorageAsync(const CreateLocationObjectStorageRequestT& request, const CreateLocationObjectStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationObjectStorage, request, handler, context);
        }
 
        virtual Model::CreateLocationS3Outcome CreateLocationS3(const Model::CreateLocationS3Request& request) const;
 
        template<typename CreateLocationS3RequestT = Model::CreateLocationS3Request>
        Model::CreateLocationS3OutcomeCallable CreateLocationS3Callable(const CreateLocationS3RequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationS3, request);
        }
 
        template<typename CreateLocationS3RequestT = Model::CreateLocationS3Request>
        void CreateLocationS3Async(const CreateLocationS3RequestT& request, const CreateLocationS3ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationS3, request, handler, context);
        }
 
        virtual Model::CreateLocationSmbOutcome CreateLocationSmb(const Model::CreateLocationSmbRequest& request) const;
 
        template<typename CreateLocationSmbRequestT = Model::CreateLocationSmbRequest>
        Model::CreateLocationSmbOutcomeCallable CreateLocationSmbCallable(const CreateLocationSmbRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateLocationSmb, request);
        }
 
        template<typename CreateLocationSmbRequestT = Model::CreateLocationSmbRequest>
        void CreateLocationSmbAsync(const CreateLocationSmbRequestT& request, const CreateLocationSmbResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateLocationSmb, request, handler, context);
        }
 
        virtual Model::CreateTaskOutcome CreateTask(const Model::CreateTaskRequest& request) const;
 
        template<typename CreateTaskRequestT = Model::CreateTaskRequest>
        Model::CreateTaskOutcomeCallable CreateTaskCallable(const CreateTaskRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::CreateTask, request);
        }
 
        template<typename CreateTaskRequestT = Model::CreateTaskRequest>
        void CreateTaskAsync(const CreateTaskRequestT& request, const CreateTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::CreateTask, request, handler, context);
        }
 
        virtual Model::DeleteAgentOutcome DeleteAgent(const Model::DeleteAgentRequest& request) const;
 
        template<typename DeleteAgentRequestT = Model::DeleteAgentRequest>
        Model::DeleteAgentOutcomeCallable DeleteAgentCallable(const DeleteAgentRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DeleteAgent, request);
        }
 
        template<typename DeleteAgentRequestT = Model::DeleteAgentRequest>
        void DeleteAgentAsync(const DeleteAgentRequestT& request, const DeleteAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DeleteAgent, request, handler, context);
        }
 
        virtual Model::DeleteLocationOutcome DeleteLocation(const Model::DeleteLocationRequest& request) const;
 
        template<typename DeleteLocationRequestT = Model::DeleteLocationRequest>
        Model::DeleteLocationOutcomeCallable DeleteLocationCallable(const DeleteLocationRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DeleteLocation, request);
        }
 
        template<typename DeleteLocationRequestT = Model::DeleteLocationRequest>
        void DeleteLocationAsync(const DeleteLocationRequestT& request, const DeleteLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DeleteLocation, request, handler, context);
        }
 
        virtual Model::DeleteTaskOutcome DeleteTask(const Model::DeleteTaskRequest& request) const;
 
        template<typename DeleteTaskRequestT = Model::DeleteTaskRequest>
        Model::DeleteTaskOutcomeCallable DeleteTaskCallable(const DeleteTaskRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DeleteTask, request);
        }
 
        template<typename DeleteTaskRequestT = Model::DeleteTaskRequest>
        void DeleteTaskAsync(const DeleteTaskRequestT& request, const DeleteTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DeleteTask, request, handler, context);
        }
 
        virtual Model::DescribeAgentOutcome DescribeAgent(const Model::DescribeAgentRequest& request) const;
 
        template<typename DescribeAgentRequestT = Model::DescribeAgentRequest>
        Model::DescribeAgentOutcomeCallable DescribeAgentCallable(const DescribeAgentRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeAgent, request);
        }
 
        template<typename DescribeAgentRequestT = Model::DescribeAgentRequest>
        void DescribeAgentAsync(const DescribeAgentRequestT& request, const DescribeAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeAgent, request, handler, context);
        }
 
        virtual Model::DescribeDiscoveryJobOutcome DescribeDiscoveryJob(const Model::DescribeDiscoveryJobRequest& request) const;
 
        template<typename DescribeDiscoveryJobRequestT = Model::DescribeDiscoveryJobRequest>
        Model::DescribeDiscoveryJobOutcomeCallable DescribeDiscoveryJobCallable(const DescribeDiscoveryJobRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeDiscoveryJob, request);
        }
 
        template<typename DescribeDiscoveryJobRequestT = Model::DescribeDiscoveryJobRequest>
        void DescribeDiscoveryJobAsync(const DescribeDiscoveryJobRequestT& request, const DescribeDiscoveryJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeDiscoveryJob, request, handler, context);
        }
 
        virtual Model::DescribeLocationAzureBlobOutcome DescribeLocationAzureBlob(const Model::DescribeLocationAzureBlobRequest& request) const;
 
        template<typename DescribeLocationAzureBlobRequestT = Model::DescribeLocationAzureBlobRequest>
        Model::DescribeLocationAzureBlobOutcomeCallable DescribeLocationAzureBlobCallable(const DescribeLocationAzureBlobRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationAzureBlob, request);
        }
 
        template<typename DescribeLocationAzureBlobRequestT = Model::DescribeLocationAzureBlobRequest>
        void DescribeLocationAzureBlobAsync(const DescribeLocationAzureBlobRequestT& request, const DescribeLocationAzureBlobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationAzureBlob, request, handler, context);
        }
 
        virtual Model::DescribeLocationEfsOutcome DescribeLocationEfs(const Model::DescribeLocationEfsRequest& request) const;
 
        template<typename DescribeLocationEfsRequestT = Model::DescribeLocationEfsRequest>
        Model::DescribeLocationEfsOutcomeCallable DescribeLocationEfsCallable(const DescribeLocationEfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationEfs, request);
        }
 
        template<typename DescribeLocationEfsRequestT = Model::DescribeLocationEfsRequest>
        void DescribeLocationEfsAsync(const DescribeLocationEfsRequestT& request, const DescribeLocationEfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationEfs, request, handler, context);
        }
 
        virtual Model::DescribeLocationFsxLustreOutcome DescribeLocationFsxLustre(const Model::DescribeLocationFsxLustreRequest& request) const;
 
        template<typename DescribeLocationFsxLustreRequestT = Model::DescribeLocationFsxLustreRequest>
        Model::DescribeLocationFsxLustreOutcomeCallable DescribeLocationFsxLustreCallable(const DescribeLocationFsxLustreRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationFsxLustre, request);
        }
 
        template<typename DescribeLocationFsxLustreRequestT = Model::DescribeLocationFsxLustreRequest>
        void DescribeLocationFsxLustreAsync(const DescribeLocationFsxLustreRequestT& request, const DescribeLocationFsxLustreResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationFsxLustre, request, handler, context);
        }
 
        virtual Model::DescribeLocationFsxOntapOutcome DescribeLocationFsxOntap(const Model::DescribeLocationFsxOntapRequest& request) const;
 
        template<typename DescribeLocationFsxOntapRequestT = Model::DescribeLocationFsxOntapRequest>
        Model::DescribeLocationFsxOntapOutcomeCallable DescribeLocationFsxOntapCallable(const DescribeLocationFsxOntapRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationFsxOntap, request);
        }
 
        template<typename DescribeLocationFsxOntapRequestT = Model::DescribeLocationFsxOntapRequest>
        void DescribeLocationFsxOntapAsync(const DescribeLocationFsxOntapRequestT& request, const DescribeLocationFsxOntapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationFsxOntap, request, handler, context);
        }
 
        virtual Model::DescribeLocationFsxOpenZfsOutcome DescribeLocationFsxOpenZfs(const Model::DescribeLocationFsxOpenZfsRequest& request) const;
 
        template<typename DescribeLocationFsxOpenZfsRequestT = Model::DescribeLocationFsxOpenZfsRequest>
        Model::DescribeLocationFsxOpenZfsOutcomeCallable DescribeLocationFsxOpenZfsCallable(const DescribeLocationFsxOpenZfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationFsxOpenZfs, request);
        }
 
        template<typename DescribeLocationFsxOpenZfsRequestT = Model::DescribeLocationFsxOpenZfsRequest>
        void DescribeLocationFsxOpenZfsAsync(const DescribeLocationFsxOpenZfsRequestT& request, const DescribeLocationFsxOpenZfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationFsxOpenZfs, request, handler, context);
        }
 
        virtual Model::DescribeLocationFsxWindowsOutcome DescribeLocationFsxWindows(const Model::DescribeLocationFsxWindowsRequest& request) const;
 
        template<typename DescribeLocationFsxWindowsRequestT = Model::DescribeLocationFsxWindowsRequest>
        Model::DescribeLocationFsxWindowsOutcomeCallable DescribeLocationFsxWindowsCallable(const DescribeLocationFsxWindowsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationFsxWindows, request);
        }
 
        template<typename DescribeLocationFsxWindowsRequestT = Model::DescribeLocationFsxWindowsRequest>
        void DescribeLocationFsxWindowsAsync(const DescribeLocationFsxWindowsRequestT& request, const DescribeLocationFsxWindowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationFsxWindows, request, handler, context);
        }
 
        virtual Model::DescribeLocationHdfsOutcome DescribeLocationHdfs(const Model::DescribeLocationHdfsRequest& request) const;
 
        template<typename DescribeLocationHdfsRequestT = Model::DescribeLocationHdfsRequest>
        Model::DescribeLocationHdfsOutcomeCallable DescribeLocationHdfsCallable(const DescribeLocationHdfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationHdfs, request);
        }
 
        template<typename DescribeLocationHdfsRequestT = Model::DescribeLocationHdfsRequest>
        void DescribeLocationHdfsAsync(const DescribeLocationHdfsRequestT& request, const DescribeLocationHdfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationHdfs, request, handler, context);
        }
 
        virtual Model::DescribeLocationNfsOutcome DescribeLocationNfs(const Model::DescribeLocationNfsRequest& request) const;
 
        template<typename DescribeLocationNfsRequestT = Model::DescribeLocationNfsRequest>
        Model::DescribeLocationNfsOutcomeCallable DescribeLocationNfsCallable(const DescribeLocationNfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationNfs, request);
        }
 
        template<typename DescribeLocationNfsRequestT = Model::DescribeLocationNfsRequest>
        void DescribeLocationNfsAsync(const DescribeLocationNfsRequestT& request, const DescribeLocationNfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationNfs, request, handler, context);
        }
 
        virtual Model::DescribeLocationObjectStorageOutcome DescribeLocationObjectStorage(const Model::DescribeLocationObjectStorageRequest& request) const;
 
        template<typename DescribeLocationObjectStorageRequestT = Model::DescribeLocationObjectStorageRequest>
        Model::DescribeLocationObjectStorageOutcomeCallable DescribeLocationObjectStorageCallable(const DescribeLocationObjectStorageRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationObjectStorage, request);
        }
 
        template<typename DescribeLocationObjectStorageRequestT = Model::DescribeLocationObjectStorageRequest>
        void DescribeLocationObjectStorageAsync(const DescribeLocationObjectStorageRequestT& request, const DescribeLocationObjectStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationObjectStorage, request, handler, context);
        }
 
        virtual Model::DescribeLocationS3Outcome DescribeLocationS3(const Model::DescribeLocationS3Request& request) const;
 
        template<typename DescribeLocationS3RequestT = Model::DescribeLocationS3Request>
        Model::DescribeLocationS3OutcomeCallable DescribeLocationS3Callable(const DescribeLocationS3RequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationS3, request);
        }
 
        template<typename DescribeLocationS3RequestT = Model::DescribeLocationS3Request>
        void DescribeLocationS3Async(const DescribeLocationS3RequestT& request, const DescribeLocationS3ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationS3, request, handler, context);
        }
 
        virtual Model::DescribeLocationSmbOutcome DescribeLocationSmb(const Model::DescribeLocationSmbRequest& request) const;
 
        template<typename DescribeLocationSmbRequestT = Model::DescribeLocationSmbRequest>
        Model::DescribeLocationSmbOutcomeCallable DescribeLocationSmbCallable(const DescribeLocationSmbRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeLocationSmb, request);
        }
 
        template<typename DescribeLocationSmbRequestT = Model::DescribeLocationSmbRequest>
        void DescribeLocationSmbAsync(const DescribeLocationSmbRequestT& request, const DescribeLocationSmbResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeLocationSmb, request, handler, context);
        }
 
        virtual Model::DescribeStorageSystemOutcome DescribeStorageSystem(const Model::DescribeStorageSystemRequest& request) const;
 
        template<typename DescribeStorageSystemRequestT = Model::DescribeStorageSystemRequest>
        Model::DescribeStorageSystemOutcomeCallable DescribeStorageSystemCallable(const DescribeStorageSystemRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeStorageSystem, request);
        }
 
        template<typename DescribeStorageSystemRequestT = Model::DescribeStorageSystemRequest>
        void DescribeStorageSystemAsync(const DescribeStorageSystemRequestT& request, const DescribeStorageSystemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeStorageSystem, request, handler, context);
        }
 
        virtual Model::DescribeStorageSystemResourceMetricsOutcome DescribeStorageSystemResourceMetrics(const Model::DescribeStorageSystemResourceMetricsRequest& request) const;
 
        template<typename DescribeStorageSystemResourceMetricsRequestT = Model::DescribeStorageSystemResourceMetricsRequest>
        Model::DescribeStorageSystemResourceMetricsOutcomeCallable DescribeStorageSystemResourceMetricsCallable(const DescribeStorageSystemResourceMetricsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeStorageSystemResourceMetrics, request);
        }
 
        template<typename DescribeStorageSystemResourceMetricsRequestT = Model::DescribeStorageSystemResourceMetricsRequest>
        void DescribeStorageSystemResourceMetricsAsync(const DescribeStorageSystemResourceMetricsRequestT& request, const DescribeStorageSystemResourceMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeStorageSystemResourceMetrics, request, handler, context);
        }
 
        virtual Model::DescribeStorageSystemResourcesOutcome DescribeStorageSystemResources(const Model::DescribeStorageSystemResourcesRequest& request) const;
 
        template<typename DescribeStorageSystemResourcesRequestT = Model::DescribeStorageSystemResourcesRequest>
        Model::DescribeStorageSystemResourcesOutcomeCallable DescribeStorageSystemResourcesCallable(const DescribeStorageSystemResourcesRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeStorageSystemResources, request);
        }
 
        template<typename DescribeStorageSystemResourcesRequestT = Model::DescribeStorageSystemResourcesRequest>
        void DescribeStorageSystemResourcesAsync(const DescribeStorageSystemResourcesRequestT& request, const DescribeStorageSystemResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeStorageSystemResources, request, handler, context);
        }
 
        virtual Model::DescribeTaskOutcome DescribeTask(const Model::DescribeTaskRequest& request) const;
 
        template<typename DescribeTaskRequestT = Model::DescribeTaskRequest>
        Model::DescribeTaskOutcomeCallable DescribeTaskCallable(const DescribeTaskRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeTask, request);
        }
 
        template<typename DescribeTaskRequestT = Model::DescribeTaskRequest>
        void DescribeTaskAsync(const DescribeTaskRequestT& request, const DescribeTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeTask, request, handler, context);
        }
 
        virtual Model::DescribeTaskExecutionOutcome DescribeTaskExecution(const Model::DescribeTaskExecutionRequest& request) const;
 
        template<typename DescribeTaskExecutionRequestT = Model::DescribeTaskExecutionRequest>
        Model::DescribeTaskExecutionOutcomeCallable DescribeTaskExecutionCallable(const DescribeTaskExecutionRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::DescribeTaskExecution, request);
        }
 
        template<typename DescribeTaskExecutionRequestT = Model::DescribeTaskExecutionRequest>
        void DescribeTaskExecutionAsync(const DescribeTaskExecutionRequestT& request, const DescribeTaskExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::DescribeTaskExecution, request, handler, context);
        }
 
        virtual Model::GenerateRecommendationsOutcome GenerateRecommendations(const Model::GenerateRecommendationsRequest& request) const;
 
        template<typename GenerateRecommendationsRequestT = Model::GenerateRecommendationsRequest>
        Model::GenerateRecommendationsOutcomeCallable GenerateRecommendationsCallable(const GenerateRecommendationsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::GenerateRecommendations, request);
        }
 
        template<typename GenerateRecommendationsRequestT = Model::GenerateRecommendationsRequest>
        void GenerateRecommendationsAsync(const GenerateRecommendationsRequestT& request, const GenerateRecommendationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::GenerateRecommendations, request, handler, context);
        }
 
        virtual Model::ListAgentsOutcome ListAgents(const Model::ListAgentsRequest& request = {}) const;
 
        template<typename ListAgentsRequestT = Model::ListAgentsRequest>
        Model::ListAgentsOutcomeCallable ListAgentsCallable(const ListAgentsRequestT& request = {}) const
        {
            return SubmitCallable(&DataSyncClient::ListAgents, request);
        }
 
        template<typename ListAgentsRequestT = Model::ListAgentsRequest>
        void ListAgentsAsync(const ListAgentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAgentsRequestT& request = {}) const
        {
            return SubmitAsync(&DataSyncClient::ListAgents, request, handler, context);
        }
 
        virtual Model::ListDiscoveryJobsOutcome ListDiscoveryJobs(const Model::ListDiscoveryJobsRequest& request = {}) const;
 
        template<typename ListDiscoveryJobsRequestT = Model::ListDiscoveryJobsRequest>
        Model::ListDiscoveryJobsOutcomeCallable ListDiscoveryJobsCallable(const ListDiscoveryJobsRequestT& request = {}) const
        {
            return SubmitCallable(&DataSyncClient::ListDiscoveryJobs, request);
        }
 
        template<typename ListDiscoveryJobsRequestT = Model::ListDiscoveryJobsRequest>
        void ListDiscoveryJobsAsync(const ListDiscoveryJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDiscoveryJobsRequestT& request = {}) const
        {
            return SubmitAsync(&DataSyncClient::ListDiscoveryJobs, request, handler, context);
        }
 
        virtual Model::ListLocationsOutcome ListLocations(const Model::ListLocationsRequest& request = {}) const;
 
        template<typename ListLocationsRequestT = Model::ListLocationsRequest>
        Model::ListLocationsOutcomeCallable ListLocationsCallable(const ListLocationsRequestT& request = {}) const
        {
            return SubmitCallable(&DataSyncClient::ListLocations, request);
        }
 
        template<typename ListLocationsRequestT = Model::ListLocationsRequest>
        void ListLocationsAsync(const ListLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLocationsRequestT& request = {}) const
        {
            return SubmitAsync(&DataSyncClient::ListLocations, request, handler, context);
        }
 
        virtual Model::ListStorageSystemsOutcome ListStorageSystems(const Model::ListStorageSystemsRequest& request = {}) const;
 
        template<typename ListStorageSystemsRequestT = Model::ListStorageSystemsRequest>
        Model::ListStorageSystemsOutcomeCallable ListStorageSystemsCallable(const ListStorageSystemsRequestT& request = {}) const
        {
            return SubmitCallable(&DataSyncClient::ListStorageSystems, request);
        }
 
        template<typename ListStorageSystemsRequestT = Model::ListStorageSystemsRequest>
        void ListStorageSystemsAsync(const ListStorageSystemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListStorageSystemsRequestT& request = {}) const
        {
            return SubmitAsync(&DataSyncClient::ListStorageSystems, 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(&DataSyncClient::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(&DataSyncClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTaskExecutionsOutcome ListTaskExecutions(const Model::ListTaskExecutionsRequest& request = {}) const;
 
        template<typename ListTaskExecutionsRequestT = Model::ListTaskExecutionsRequest>
        Model::ListTaskExecutionsOutcomeCallable ListTaskExecutionsCallable(const ListTaskExecutionsRequestT& request = {}) const
        {
            return SubmitCallable(&DataSyncClient::ListTaskExecutions, request);
        }
 
        template<typename ListTaskExecutionsRequestT = Model::ListTaskExecutionsRequest>
        void ListTaskExecutionsAsync(const ListTaskExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTaskExecutionsRequestT& request = {}) const
        {
            return SubmitAsync(&DataSyncClient::ListTaskExecutions, request, handler, context);
        }
 
        virtual Model::ListTasksOutcome ListTasks(const Model::ListTasksRequest& request = {}) const;
 
        template<typename ListTasksRequestT = Model::ListTasksRequest>
        Model::ListTasksOutcomeCallable ListTasksCallable(const ListTasksRequestT& request = {}) const
        {
            return SubmitCallable(&DataSyncClient::ListTasks, request);
        }
 
        template<typename ListTasksRequestT = Model::ListTasksRequest>
        void ListTasksAsync(const ListTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTasksRequestT& request = {}) const
        {
            return SubmitAsync(&DataSyncClient::ListTasks, request, handler, context);
        }
 
        virtual Model::RemoveStorageSystemOutcome RemoveStorageSystem(const Model::RemoveStorageSystemRequest& request) const;
 
        template<typename RemoveStorageSystemRequestT = Model::RemoveStorageSystemRequest>
        Model::RemoveStorageSystemOutcomeCallable RemoveStorageSystemCallable(const RemoveStorageSystemRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::RemoveStorageSystem, request);
        }
 
        template<typename RemoveStorageSystemRequestT = Model::RemoveStorageSystemRequest>
        void RemoveStorageSystemAsync(const RemoveStorageSystemRequestT& request, const RemoveStorageSystemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::RemoveStorageSystem, request, handler, context);
        }
 
        virtual Model::StartDiscoveryJobOutcome StartDiscoveryJob(const Model::StartDiscoveryJobRequest& request) const;
 
        template<typename StartDiscoveryJobRequestT = Model::StartDiscoveryJobRequest>
        Model::StartDiscoveryJobOutcomeCallable StartDiscoveryJobCallable(const StartDiscoveryJobRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::StartDiscoveryJob, request);
        }
 
        template<typename StartDiscoveryJobRequestT = Model::StartDiscoveryJobRequest>
        void StartDiscoveryJobAsync(const StartDiscoveryJobRequestT& request, const StartDiscoveryJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::StartDiscoveryJob, request, handler, context);
        }
 
        virtual Model::StartTaskExecutionOutcome StartTaskExecution(const Model::StartTaskExecutionRequest& request) const;
 
        template<typename StartTaskExecutionRequestT = Model::StartTaskExecutionRequest>
        Model::StartTaskExecutionOutcomeCallable StartTaskExecutionCallable(const StartTaskExecutionRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::StartTaskExecution, request);
        }
 
        template<typename StartTaskExecutionRequestT = Model::StartTaskExecutionRequest>
        void StartTaskExecutionAsync(const StartTaskExecutionRequestT& request, const StartTaskExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::StartTaskExecution, request, handler, context);
        }
 
        virtual Model::StopDiscoveryJobOutcome StopDiscoveryJob(const Model::StopDiscoveryJobRequest& request) const;
 
        template<typename StopDiscoveryJobRequestT = Model::StopDiscoveryJobRequest>
        Model::StopDiscoveryJobOutcomeCallable StopDiscoveryJobCallable(const StopDiscoveryJobRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::StopDiscoveryJob, request);
        }
 
        template<typename StopDiscoveryJobRequestT = Model::StopDiscoveryJobRequest>
        void StopDiscoveryJobAsync(const StopDiscoveryJobRequestT& request, const StopDiscoveryJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::StopDiscoveryJob, 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(&DataSyncClient::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(&DataSyncClient::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(&DataSyncClient::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(&DataSyncClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAgentOutcome UpdateAgent(const Model::UpdateAgentRequest& request) const;
 
        template<typename UpdateAgentRequestT = Model::UpdateAgentRequest>
        Model::UpdateAgentOutcomeCallable UpdateAgentCallable(const UpdateAgentRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateAgent, request);
        }
 
        template<typename UpdateAgentRequestT = Model::UpdateAgentRequest>
        void UpdateAgentAsync(const UpdateAgentRequestT& request, const UpdateAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateAgent, request, handler, context);
        }
 
        virtual Model::UpdateDiscoveryJobOutcome UpdateDiscoveryJob(const Model::UpdateDiscoveryJobRequest& request) const;
 
        template<typename UpdateDiscoveryJobRequestT = Model::UpdateDiscoveryJobRequest>
        Model::UpdateDiscoveryJobOutcomeCallable UpdateDiscoveryJobCallable(const UpdateDiscoveryJobRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateDiscoveryJob, request);
        }
 
        template<typename UpdateDiscoveryJobRequestT = Model::UpdateDiscoveryJobRequest>
        void UpdateDiscoveryJobAsync(const UpdateDiscoveryJobRequestT& request, const UpdateDiscoveryJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateDiscoveryJob, request, handler, context);
        }
 
        virtual Model::UpdateLocationAzureBlobOutcome UpdateLocationAzureBlob(const Model::UpdateLocationAzureBlobRequest& request) const;
 
        template<typename UpdateLocationAzureBlobRequestT = Model::UpdateLocationAzureBlobRequest>
        Model::UpdateLocationAzureBlobOutcomeCallable UpdateLocationAzureBlobCallable(const UpdateLocationAzureBlobRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateLocationAzureBlob, request);
        }
 
        template<typename UpdateLocationAzureBlobRequestT = Model::UpdateLocationAzureBlobRequest>
        void UpdateLocationAzureBlobAsync(const UpdateLocationAzureBlobRequestT& request, const UpdateLocationAzureBlobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateLocationAzureBlob, request, handler, context);
        }
 
        virtual Model::UpdateLocationHdfsOutcome UpdateLocationHdfs(const Model::UpdateLocationHdfsRequest& request) const;
 
        template<typename UpdateLocationHdfsRequestT = Model::UpdateLocationHdfsRequest>
        Model::UpdateLocationHdfsOutcomeCallable UpdateLocationHdfsCallable(const UpdateLocationHdfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateLocationHdfs, request);
        }
 
        template<typename UpdateLocationHdfsRequestT = Model::UpdateLocationHdfsRequest>
        void UpdateLocationHdfsAsync(const UpdateLocationHdfsRequestT& request, const UpdateLocationHdfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateLocationHdfs, request, handler, context);
        }
 
        virtual Model::UpdateLocationNfsOutcome UpdateLocationNfs(const Model::UpdateLocationNfsRequest& request) const;
 
        template<typename UpdateLocationNfsRequestT = Model::UpdateLocationNfsRequest>
        Model::UpdateLocationNfsOutcomeCallable UpdateLocationNfsCallable(const UpdateLocationNfsRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateLocationNfs, request);
        }
 
        template<typename UpdateLocationNfsRequestT = Model::UpdateLocationNfsRequest>
        void UpdateLocationNfsAsync(const UpdateLocationNfsRequestT& request, const UpdateLocationNfsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateLocationNfs, request, handler, context);
        }
 
        virtual Model::UpdateLocationObjectStorageOutcome UpdateLocationObjectStorage(const Model::UpdateLocationObjectStorageRequest& request) const;
 
        template<typename UpdateLocationObjectStorageRequestT = Model::UpdateLocationObjectStorageRequest>
        Model::UpdateLocationObjectStorageOutcomeCallable UpdateLocationObjectStorageCallable(const UpdateLocationObjectStorageRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateLocationObjectStorage, request);
        }
 
        template<typename UpdateLocationObjectStorageRequestT = Model::UpdateLocationObjectStorageRequest>
        void UpdateLocationObjectStorageAsync(const UpdateLocationObjectStorageRequestT& request, const UpdateLocationObjectStorageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateLocationObjectStorage, request, handler, context);
        }
 
        virtual Model::UpdateLocationSmbOutcome UpdateLocationSmb(const Model::UpdateLocationSmbRequest& request) const;
 
        template<typename UpdateLocationSmbRequestT = Model::UpdateLocationSmbRequest>
        Model::UpdateLocationSmbOutcomeCallable UpdateLocationSmbCallable(const UpdateLocationSmbRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateLocationSmb, request);
        }
 
        template<typename UpdateLocationSmbRequestT = Model::UpdateLocationSmbRequest>
        void UpdateLocationSmbAsync(const UpdateLocationSmbRequestT& request, const UpdateLocationSmbResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateLocationSmb, request, handler, context);
        }
 
        virtual Model::UpdateStorageSystemOutcome UpdateStorageSystem(const Model::UpdateStorageSystemRequest& request) const;
 
        template<typename UpdateStorageSystemRequestT = Model::UpdateStorageSystemRequest>
        Model::UpdateStorageSystemOutcomeCallable UpdateStorageSystemCallable(const UpdateStorageSystemRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateStorageSystem, request);
        }
 
        template<typename UpdateStorageSystemRequestT = Model::UpdateStorageSystemRequest>
        void UpdateStorageSystemAsync(const UpdateStorageSystemRequestT& request, const UpdateStorageSystemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateStorageSystem, request, handler, context);
        }
 
        virtual Model::UpdateTaskOutcome UpdateTask(const Model::UpdateTaskRequest& request) const;
 
        template<typename UpdateTaskRequestT = Model::UpdateTaskRequest>
        Model::UpdateTaskOutcomeCallable UpdateTaskCallable(const UpdateTaskRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateTask, request);
        }
 
        template<typename UpdateTaskRequestT = Model::UpdateTaskRequest>
        void UpdateTaskAsync(const UpdateTaskRequestT& request, const UpdateTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateTask, request, handler, context);
        }
 
        virtual Model::UpdateTaskExecutionOutcome UpdateTaskExecution(const Model::UpdateTaskExecutionRequest& request) const;
 
        template<typename UpdateTaskExecutionRequestT = Model::UpdateTaskExecutionRequest>
        Model::UpdateTaskExecutionOutcomeCallable UpdateTaskExecutionCallable(const UpdateTaskExecutionRequestT& request) const
        {
            return SubmitCallable(&DataSyncClient::UpdateTaskExecution, request);
        }
 
        template<typename UpdateTaskExecutionRequestT = Model::UpdateTaskExecutionRequest>
        void UpdateTaskExecutionAsync(const UpdateTaskExecutionRequestT& request, const UpdateTaskExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DataSyncClient::UpdateTaskExecution, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DataSyncEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DataSyncClient>;
      void init(const DataSyncClientConfiguration& clientConfiguration);
 
      DataSyncClientConfiguration m_clientConfiguration;
      std::shared_ptr<DataSyncEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace DataSync
} // namespace Aws