DataSyncClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/datasync/DataSyncPaginationBase.h>
#include <aws/datasync/DataSyncServiceClientModel.h>
#include <aws/datasync/DataSyncWaiter.h>
#include <aws/datasync/DataSync_EXPORTS.h>
 
namespace Aws {
namespace DataSync {
class AWS_DATASYNC_API DataSyncClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<DataSyncClient>,
                                        public DataSyncPaginationBase<DataSyncClient>,
                                        public DataSyncWaiter<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::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::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::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::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::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::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::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::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::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::UpdateLocationEfsOutcome UpdateLocationEfs(const Model::UpdateLocationEfsRequest& request) const;
 
  template <typename UpdateLocationEfsRequestT = Model::UpdateLocationEfsRequest>
  Model::UpdateLocationEfsOutcomeCallable UpdateLocationEfsCallable(const UpdateLocationEfsRequestT& request) const {
    return SubmitCallable(&DataSyncClient::UpdateLocationEfs, request);
  }
 
  template <typename UpdateLocationEfsRequestT = Model::UpdateLocationEfsRequest>
  void UpdateLocationEfsAsync(const UpdateLocationEfsRequestT& request, const UpdateLocationEfsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataSyncClient::UpdateLocationEfs, request, handler, context);
  }
 
  virtual Model::UpdateLocationFsxLustreOutcome UpdateLocationFsxLustre(const Model::UpdateLocationFsxLustreRequest& request) const;
 
  template <typename UpdateLocationFsxLustreRequestT = Model::UpdateLocationFsxLustreRequest>
  Model::UpdateLocationFsxLustreOutcomeCallable UpdateLocationFsxLustreCallable(const UpdateLocationFsxLustreRequestT& request) const {
    return SubmitCallable(&DataSyncClient::UpdateLocationFsxLustre, request);
  }
 
  template <typename UpdateLocationFsxLustreRequestT = Model::UpdateLocationFsxLustreRequest>
  void UpdateLocationFsxLustreAsync(const UpdateLocationFsxLustreRequestT& request,
                                    const UpdateLocationFsxLustreResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataSyncClient::UpdateLocationFsxLustre, request, handler, context);
  }
 
  virtual Model::UpdateLocationFsxOntapOutcome UpdateLocationFsxOntap(const Model::UpdateLocationFsxOntapRequest& request) const;
 
  template <typename UpdateLocationFsxOntapRequestT = Model::UpdateLocationFsxOntapRequest>
  Model::UpdateLocationFsxOntapOutcomeCallable UpdateLocationFsxOntapCallable(const UpdateLocationFsxOntapRequestT& request) const {
    return SubmitCallable(&DataSyncClient::UpdateLocationFsxOntap, request);
  }
 
  template <typename UpdateLocationFsxOntapRequestT = Model::UpdateLocationFsxOntapRequest>
  void UpdateLocationFsxOntapAsync(const UpdateLocationFsxOntapRequestT& request,
                                   const UpdateLocationFsxOntapResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataSyncClient::UpdateLocationFsxOntap, request, handler, context);
  }
 
  virtual Model::UpdateLocationFsxOpenZfsOutcome UpdateLocationFsxOpenZfs(const Model::UpdateLocationFsxOpenZfsRequest& request) const;
 
  template <typename UpdateLocationFsxOpenZfsRequestT = Model::UpdateLocationFsxOpenZfsRequest>
  Model::UpdateLocationFsxOpenZfsOutcomeCallable UpdateLocationFsxOpenZfsCallable(const UpdateLocationFsxOpenZfsRequestT& request) const {
    return SubmitCallable(&DataSyncClient::UpdateLocationFsxOpenZfs, request);
  }
 
  template <typename UpdateLocationFsxOpenZfsRequestT = Model::UpdateLocationFsxOpenZfsRequest>
  void UpdateLocationFsxOpenZfsAsync(const UpdateLocationFsxOpenZfsRequestT& request,
                                     const UpdateLocationFsxOpenZfsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataSyncClient::UpdateLocationFsxOpenZfs, request, handler, context);
  }
 
  virtual Model::UpdateLocationFsxWindowsOutcome UpdateLocationFsxWindows(const Model::UpdateLocationFsxWindowsRequest& request) const;
 
  template <typename UpdateLocationFsxWindowsRequestT = Model::UpdateLocationFsxWindowsRequest>
  Model::UpdateLocationFsxWindowsOutcomeCallable UpdateLocationFsxWindowsCallable(const UpdateLocationFsxWindowsRequestT& request) const {
    return SubmitCallable(&DataSyncClient::UpdateLocationFsxWindows, request);
  }
 
  template <typename UpdateLocationFsxWindowsRequestT = Model::UpdateLocationFsxWindowsRequest>
  void UpdateLocationFsxWindowsAsync(const UpdateLocationFsxWindowsRequestT& request,
                                     const UpdateLocationFsxWindowsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataSyncClient::UpdateLocationFsxWindows, 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::UpdateLocationS3Outcome UpdateLocationS3(const Model::UpdateLocationS3Request& request) const;
 
  template <typename UpdateLocationS3RequestT = Model::UpdateLocationS3Request>
  Model::UpdateLocationS3OutcomeCallable UpdateLocationS3Callable(const UpdateLocationS3RequestT& request) const {
    return SubmitCallable(&DataSyncClient::UpdateLocationS3, request);
  }
 
  template <typename UpdateLocationS3RequestT = Model::UpdateLocationS3Request>
  void UpdateLocationS3Async(const UpdateLocationS3RequestT& request, const UpdateLocationS3ResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DataSyncClient::UpdateLocationS3, 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::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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DataSyncEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DataSyncClient>;
  void init(const DataSyncClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DataSyncError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  DataSyncClientConfiguration m_clientConfiguration;
  std::shared_ptr<DataSyncEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DataSync
}  // namespace Aws