TransferClient.h

 
#pragma once
#include <aws/awstransfer/TransferPaginationBase.h>
#include <aws/awstransfer/TransferServiceClientModel.h>
#include <aws/awstransfer/TransferWaiter.h>
#include <aws/awstransfer/Transfer_EXPORTS.h>
#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>
 
namespace Aws {
namespace Transfer {
class AWS_TRANSFER_API TransferClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<TransferClient>,
                                        public TransferPaginationBase<TransferClient>,
                                        public TransferWaiter<TransferClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef TransferClientConfiguration ClientConfigurationType;
  typedef TransferEndpointProvider EndpointProviderType;
 
  TransferClient(const Aws::Transfer::TransferClientConfiguration& clientConfiguration = Aws::Transfer::TransferClientConfiguration(),
                 std::shared_ptr<TransferEndpointProviderBase> endpointProvider = nullptr);
 
  TransferClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<TransferEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Transfer::TransferClientConfiguration& clientConfiguration = Aws::Transfer::TransferClientConfiguration());
 
  TransferClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 std::shared_ptr<TransferEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Transfer::TransferClientConfiguration& clientConfiguration = Aws::Transfer::TransferClientConfiguration());
 
  /* Legacy constructors due deprecation */
  TransferClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TransferClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TransferClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~TransferClient();
 
  virtual Model::CreateAccessOutcome CreateAccess(const Model::CreateAccessRequest& request) const;
 
  template <typename CreateAccessRequestT = Model::CreateAccessRequest>
  Model::CreateAccessOutcomeCallable CreateAccessCallable(const CreateAccessRequestT& request) const {
    return SubmitCallable(&TransferClient::CreateAccess, request);
  }
 
  template <typename CreateAccessRequestT = Model::CreateAccessRequest>
  void CreateAccessAsync(const CreateAccessRequestT& request, const CreateAccessResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::CreateAccess, request, handler, context);
  }
 
  virtual Model::CreateAgreementOutcome CreateAgreement(const Model::CreateAgreementRequest& request) const;
 
  template <typename CreateAgreementRequestT = Model::CreateAgreementRequest>
  Model::CreateAgreementOutcomeCallable CreateAgreementCallable(const CreateAgreementRequestT& request) const {
    return SubmitCallable(&TransferClient::CreateAgreement, request);
  }
 
  template <typename CreateAgreementRequestT = Model::CreateAgreementRequest>
  void CreateAgreementAsync(const CreateAgreementRequestT& request, const CreateAgreementResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::CreateAgreement, request, handler, context);
  }
 
  virtual Model::CreateConnectorOutcome CreateConnector(const Model::CreateConnectorRequest& request) const;
 
  template <typename CreateConnectorRequestT = Model::CreateConnectorRequest>
  Model::CreateConnectorOutcomeCallable CreateConnectorCallable(const CreateConnectorRequestT& request) const {
    return SubmitCallable(&TransferClient::CreateConnector, request);
  }
 
  template <typename CreateConnectorRequestT = Model::CreateConnectorRequest>
  void CreateConnectorAsync(const CreateConnectorRequestT& request, const CreateConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::CreateConnector, request, handler, context);
  }
 
  virtual Model::CreateProfileOutcome CreateProfile(const Model::CreateProfileRequest& request) const;
 
  template <typename CreateProfileRequestT = Model::CreateProfileRequest>
  Model::CreateProfileOutcomeCallable CreateProfileCallable(const CreateProfileRequestT& request) const {
    return SubmitCallable(&TransferClient::CreateProfile, request);
  }
 
  template <typename CreateProfileRequestT = Model::CreateProfileRequest>
  void CreateProfileAsync(const CreateProfileRequestT& request, const CreateProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::CreateProfile, request, handler, context);
  }
 
  virtual Model::CreateServerOutcome CreateServer(const Model::CreateServerRequest& request = {}) const;
 
  template <typename CreateServerRequestT = Model::CreateServerRequest>
  Model::CreateServerOutcomeCallable CreateServerCallable(const CreateServerRequestT& request = {}) const {
    return SubmitCallable(&TransferClient::CreateServer, request);
  }
 
  template <typename CreateServerRequestT = Model::CreateServerRequest>
  void CreateServerAsync(const CreateServerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const CreateServerRequestT& request = {}) const {
    return SubmitAsync(&TransferClient::CreateServer, request, handler, context);
  }
 
  virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const {
    return SubmitCallable(&TransferClient::CreateUser, request);
  }
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::CreateUser, request, handler, context);
  }
 
  virtual Model::CreateWebAppOutcome CreateWebApp(const Model::CreateWebAppRequest& request) const;
 
  template <typename CreateWebAppRequestT = Model::CreateWebAppRequest>
  Model::CreateWebAppOutcomeCallable CreateWebAppCallable(const CreateWebAppRequestT& request) const {
    return SubmitCallable(&TransferClient::CreateWebApp, request);
  }
 
  template <typename CreateWebAppRequestT = Model::CreateWebAppRequest>
  void CreateWebAppAsync(const CreateWebAppRequestT& request, const CreateWebAppResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::CreateWebApp, request, handler, context);
  }
 
  virtual Model::CreateWorkflowOutcome CreateWorkflow(const Model::CreateWorkflowRequest& request) const;
 
  template <typename CreateWorkflowRequestT = Model::CreateWorkflowRequest>
  Model::CreateWorkflowOutcomeCallable CreateWorkflowCallable(const CreateWorkflowRequestT& request) const {
    return SubmitCallable(&TransferClient::CreateWorkflow, request);
  }
 
  template <typename CreateWorkflowRequestT = Model::CreateWorkflowRequest>
  void CreateWorkflowAsync(const CreateWorkflowRequestT& request, const CreateWorkflowResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::CreateWorkflow, request, handler, context);
  }
 
  virtual Model::DeleteAccessOutcome DeleteAccess(const Model::DeleteAccessRequest& request) const;
 
  template <typename DeleteAccessRequestT = Model::DeleteAccessRequest>
  Model::DeleteAccessOutcomeCallable DeleteAccessCallable(const DeleteAccessRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteAccess, request);
  }
 
  template <typename DeleteAccessRequestT = Model::DeleteAccessRequest>
  void DeleteAccessAsync(const DeleteAccessRequestT& request, const DeleteAccessResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteAccess, request, handler, context);
  }
 
  virtual Model::DeleteAgreementOutcome DeleteAgreement(const Model::DeleteAgreementRequest& request) const;
 
  template <typename DeleteAgreementRequestT = Model::DeleteAgreementRequest>
  Model::DeleteAgreementOutcomeCallable DeleteAgreementCallable(const DeleteAgreementRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteAgreement, request);
  }
 
  template <typename DeleteAgreementRequestT = Model::DeleteAgreementRequest>
  void DeleteAgreementAsync(const DeleteAgreementRequestT& request, const DeleteAgreementResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteAgreement, request, handler, context);
  }
 
  virtual Model::DeleteCertificateOutcome DeleteCertificate(const Model::DeleteCertificateRequest& request) const;
 
  template <typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
  Model::DeleteCertificateOutcomeCallable DeleteCertificateCallable(const DeleteCertificateRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteCertificate, request);
  }
 
  template <typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
  void DeleteCertificateAsync(const DeleteCertificateRequestT& request, const DeleteCertificateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteCertificate, request, handler, context);
  }
 
  virtual Model::DeleteConnectorOutcome DeleteConnector(const Model::DeleteConnectorRequest& request) const;
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  Model::DeleteConnectorOutcomeCallable DeleteConnectorCallable(const DeleteConnectorRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteConnector, request);
  }
 
  template <typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
  void DeleteConnectorAsync(const DeleteConnectorRequestT& request, const DeleteConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteConnector, request, handler, context);
  }
 
  virtual Model::DeleteHostKeyOutcome DeleteHostKey(const Model::DeleteHostKeyRequest& request) const;
 
  template <typename DeleteHostKeyRequestT = Model::DeleteHostKeyRequest>
  Model::DeleteHostKeyOutcomeCallable DeleteHostKeyCallable(const DeleteHostKeyRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteHostKey, request);
  }
 
  template <typename DeleteHostKeyRequestT = Model::DeleteHostKeyRequest>
  void DeleteHostKeyAsync(const DeleteHostKeyRequestT& request, const DeleteHostKeyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteHostKey, request, handler, context);
  }
 
  virtual Model::DeleteProfileOutcome DeleteProfile(const Model::DeleteProfileRequest& request) const;
 
  template <typename DeleteProfileRequestT = Model::DeleteProfileRequest>
  Model::DeleteProfileOutcomeCallable DeleteProfileCallable(const DeleteProfileRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteProfile, request);
  }
 
  template <typename DeleteProfileRequestT = Model::DeleteProfileRequest>
  void DeleteProfileAsync(const DeleteProfileRequestT& request, const DeleteProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteProfile, request, handler, context);
  }
 
  virtual Model::DeleteServerOutcome DeleteServer(const Model::DeleteServerRequest& request) const;
 
  template <typename DeleteServerRequestT = Model::DeleteServerRequest>
  Model::DeleteServerOutcomeCallable DeleteServerCallable(const DeleteServerRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteServer, request);
  }
 
  template <typename DeleteServerRequestT = Model::DeleteServerRequest>
  void DeleteServerAsync(const DeleteServerRequestT& request, const DeleteServerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteServer, request, handler, context);
  }
 
  virtual Model::DeleteSshPublicKeyOutcome DeleteSshPublicKey(const Model::DeleteSshPublicKeyRequest& request) const;
 
  template <typename DeleteSshPublicKeyRequestT = Model::DeleteSshPublicKeyRequest>
  Model::DeleteSshPublicKeyOutcomeCallable DeleteSshPublicKeyCallable(const DeleteSshPublicKeyRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteSshPublicKey, request);
  }
 
  template <typename DeleteSshPublicKeyRequestT = Model::DeleteSshPublicKeyRequest>
  void DeleteSshPublicKeyAsync(const DeleteSshPublicKeyRequestT& request, const DeleteSshPublicKeyResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteSshPublicKey, request, handler, context);
  }
 
  virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteUser, request);
  }
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteUser, request, handler, context);
  }
 
  virtual Model::DeleteWebAppOutcome DeleteWebApp(const Model::DeleteWebAppRequest& request) const;
 
  template <typename DeleteWebAppRequestT = Model::DeleteWebAppRequest>
  Model::DeleteWebAppOutcomeCallable DeleteWebAppCallable(const DeleteWebAppRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteWebApp, request);
  }
 
  template <typename DeleteWebAppRequestT = Model::DeleteWebAppRequest>
  void DeleteWebAppAsync(const DeleteWebAppRequestT& request, const DeleteWebAppResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteWebApp, request, handler, context);
  }
 
  virtual Model::DeleteWebAppCustomizationOutcome DeleteWebAppCustomization(const Model::DeleteWebAppCustomizationRequest& request) const;
 
  template <typename DeleteWebAppCustomizationRequestT = Model::DeleteWebAppCustomizationRequest>
  Model::DeleteWebAppCustomizationOutcomeCallable DeleteWebAppCustomizationCallable(
      const DeleteWebAppCustomizationRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteWebAppCustomization, request);
  }
 
  template <typename DeleteWebAppCustomizationRequestT = Model::DeleteWebAppCustomizationRequest>
  void DeleteWebAppCustomizationAsync(const DeleteWebAppCustomizationRequestT& request,
                                      const DeleteWebAppCustomizationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteWebAppCustomization, request, handler, context);
  }
 
  virtual Model::DeleteWorkflowOutcome DeleteWorkflow(const Model::DeleteWorkflowRequest& request) const;
 
  template <typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
  Model::DeleteWorkflowOutcomeCallable DeleteWorkflowCallable(const DeleteWorkflowRequestT& request) const {
    return SubmitCallable(&TransferClient::DeleteWorkflow, request);
  }
 
  template <typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
  void DeleteWorkflowAsync(const DeleteWorkflowRequestT& request, const DeleteWorkflowResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DeleteWorkflow, request, handler, context);
  }
 
  virtual Model::DescribeAccessOutcome DescribeAccess(const Model::DescribeAccessRequest& request) const;
 
  template <typename DescribeAccessRequestT = Model::DescribeAccessRequest>
  Model::DescribeAccessOutcomeCallable DescribeAccessCallable(const DescribeAccessRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeAccess, request);
  }
 
  template <typename DescribeAccessRequestT = Model::DescribeAccessRequest>
  void DescribeAccessAsync(const DescribeAccessRequestT& request, const DescribeAccessResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeAccess, request, handler, context);
  }
 
  virtual Model::DescribeAgreementOutcome DescribeAgreement(const Model::DescribeAgreementRequest& request) const;
 
  template <typename DescribeAgreementRequestT = Model::DescribeAgreementRequest>
  Model::DescribeAgreementOutcomeCallable DescribeAgreementCallable(const DescribeAgreementRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeAgreement, request);
  }
 
  template <typename DescribeAgreementRequestT = Model::DescribeAgreementRequest>
  void DescribeAgreementAsync(const DescribeAgreementRequestT& request, const DescribeAgreementResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeAgreement, request, handler, context);
  }
 
  virtual Model::DescribeCertificateOutcome DescribeCertificate(const Model::DescribeCertificateRequest& request) const;
 
  template <typename DescribeCertificateRequestT = Model::DescribeCertificateRequest>
  Model::DescribeCertificateOutcomeCallable DescribeCertificateCallable(const DescribeCertificateRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeCertificate, request);
  }
 
  template <typename DescribeCertificateRequestT = Model::DescribeCertificateRequest>
  void DescribeCertificateAsync(const DescribeCertificateRequestT& request, const DescribeCertificateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeCertificate, request, handler, context);
  }
 
  virtual Model::DescribeConnectorOutcome DescribeConnector(const Model::DescribeConnectorRequest& request) const;
 
  template <typename DescribeConnectorRequestT = Model::DescribeConnectorRequest>
  Model::DescribeConnectorOutcomeCallable DescribeConnectorCallable(const DescribeConnectorRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeConnector, request);
  }
 
  template <typename DescribeConnectorRequestT = Model::DescribeConnectorRequest>
  void DescribeConnectorAsync(const DescribeConnectorRequestT& request, const DescribeConnectorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeConnector, request, handler, context);
  }
 
  virtual Model::DescribeExecutionOutcome DescribeExecution(const Model::DescribeExecutionRequest& request) const;
 
  template <typename DescribeExecutionRequestT = Model::DescribeExecutionRequest>
  Model::DescribeExecutionOutcomeCallable DescribeExecutionCallable(const DescribeExecutionRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeExecution, request);
  }
 
  template <typename DescribeExecutionRequestT = Model::DescribeExecutionRequest>
  void DescribeExecutionAsync(const DescribeExecutionRequestT& request, const DescribeExecutionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeExecution, request, handler, context);
  }
 
  virtual Model::DescribeHostKeyOutcome DescribeHostKey(const Model::DescribeHostKeyRequest& request) const;
 
  template <typename DescribeHostKeyRequestT = Model::DescribeHostKeyRequest>
  Model::DescribeHostKeyOutcomeCallable DescribeHostKeyCallable(const DescribeHostKeyRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeHostKey, request);
  }
 
  template <typename DescribeHostKeyRequestT = Model::DescribeHostKeyRequest>
  void DescribeHostKeyAsync(const DescribeHostKeyRequestT& request, const DescribeHostKeyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeHostKey, request, handler, context);
  }
 
  virtual Model::DescribeProfileOutcome DescribeProfile(const Model::DescribeProfileRequest& request) const;
 
  template <typename DescribeProfileRequestT = Model::DescribeProfileRequest>
  Model::DescribeProfileOutcomeCallable DescribeProfileCallable(const DescribeProfileRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeProfile, request);
  }
 
  template <typename DescribeProfileRequestT = Model::DescribeProfileRequest>
  void DescribeProfileAsync(const DescribeProfileRequestT& request, const DescribeProfileResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeProfile, request, handler, context);
  }
 
  virtual Model::DescribeSecurityPolicyOutcome DescribeSecurityPolicy(const Model::DescribeSecurityPolicyRequest& request) const;
 
  template <typename DescribeSecurityPolicyRequestT = Model::DescribeSecurityPolicyRequest>
  Model::DescribeSecurityPolicyOutcomeCallable DescribeSecurityPolicyCallable(const DescribeSecurityPolicyRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeSecurityPolicy, request);
  }
 
  template <typename DescribeSecurityPolicyRequestT = Model::DescribeSecurityPolicyRequest>
  void DescribeSecurityPolicyAsync(const DescribeSecurityPolicyRequestT& request,
                                   const DescribeSecurityPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeSecurityPolicy, request, handler, context);
  }
 
  virtual Model::DescribeServerOutcome DescribeServer(const Model::DescribeServerRequest& request) const;
 
  template <typename DescribeServerRequestT = Model::DescribeServerRequest>
  Model::DescribeServerOutcomeCallable DescribeServerCallable(const DescribeServerRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeServer, request);
  }
 
  template <typename DescribeServerRequestT = Model::DescribeServerRequest>
  void DescribeServerAsync(const DescribeServerRequestT& request, const DescribeServerResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeServer, request, handler, context);
  }
 
  virtual Model::DescribeUserOutcome DescribeUser(const Model::DescribeUserRequest& request) const;
 
  template <typename DescribeUserRequestT = Model::DescribeUserRequest>
  Model::DescribeUserOutcomeCallable DescribeUserCallable(const DescribeUserRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeUser, request);
  }
 
  template <typename DescribeUserRequestT = Model::DescribeUserRequest>
  void DescribeUserAsync(const DescribeUserRequestT& request, const DescribeUserResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeUser, request, handler, context);
  }
 
  virtual Model::DescribeWebAppOutcome DescribeWebApp(const Model::DescribeWebAppRequest& request) const;
 
  template <typename DescribeWebAppRequestT = Model::DescribeWebAppRequest>
  Model::DescribeWebAppOutcomeCallable DescribeWebAppCallable(const DescribeWebAppRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeWebApp, request);
  }
 
  template <typename DescribeWebAppRequestT = Model::DescribeWebAppRequest>
  void DescribeWebAppAsync(const DescribeWebAppRequestT& request, const DescribeWebAppResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeWebApp, request, handler, context);
  }
 
  virtual Model::DescribeWebAppCustomizationOutcome DescribeWebAppCustomization(
      const Model::DescribeWebAppCustomizationRequest& request) const;
 
  template <typename DescribeWebAppCustomizationRequestT = Model::DescribeWebAppCustomizationRequest>
  Model::DescribeWebAppCustomizationOutcomeCallable DescribeWebAppCustomizationCallable(
      const DescribeWebAppCustomizationRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeWebAppCustomization, request);
  }
 
  template <typename DescribeWebAppCustomizationRequestT = Model::DescribeWebAppCustomizationRequest>
  void DescribeWebAppCustomizationAsync(const DescribeWebAppCustomizationRequestT& request,
                                        const DescribeWebAppCustomizationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeWebAppCustomization, request, handler, context);
  }
 
  virtual Model::DescribeWorkflowOutcome DescribeWorkflow(const Model::DescribeWorkflowRequest& request) const;
 
  template <typename DescribeWorkflowRequestT = Model::DescribeWorkflowRequest>
  Model::DescribeWorkflowOutcomeCallable DescribeWorkflowCallable(const DescribeWorkflowRequestT& request) const {
    return SubmitCallable(&TransferClient::DescribeWorkflow, request);
  }
 
  template <typename DescribeWorkflowRequestT = Model::DescribeWorkflowRequest>
  void DescribeWorkflowAsync(const DescribeWorkflowRequestT& request, const DescribeWorkflowResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::DescribeWorkflow, request, handler, context);
  }
 
  virtual Model::ImportCertificateOutcome ImportCertificate(const Model::ImportCertificateRequest& request) const;
 
  template <typename ImportCertificateRequestT = Model::ImportCertificateRequest>
  Model::ImportCertificateOutcomeCallable ImportCertificateCallable(const ImportCertificateRequestT& request) const {
    return SubmitCallable(&TransferClient::ImportCertificate, request);
  }
 
  template <typename ImportCertificateRequestT = Model::ImportCertificateRequest>
  void ImportCertificateAsync(const ImportCertificateRequestT& request, const ImportCertificateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::ImportCertificate, request, handler, context);
  }
 
  virtual Model::ImportHostKeyOutcome ImportHostKey(const Model::ImportHostKeyRequest& request) const;
 
  template <typename ImportHostKeyRequestT = Model::ImportHostKeyRequest>
  Model::ImportHostKeyOutcomeCallable ImportHostKeyCallable(const ImportHostKeyRequestT& request) const {
    return SubmitCallable(&TransferClient::ImportHostKey, request);
  }
 
  template <typename ImportHostKeyRequestT = Model::ImportHostKeyRequest>
  void ImportHostKeyAsync(const ImportHostKeyRequestT& request, const ImportHostKeyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::ImportHostKey, request, handler, context);
  }
 
  virtual Model::ImportSshPublicKeyOutcome ImportSshPublicKey(const Model::ImportSshPublicKeyRequest& request) const;
 
  template <typename ImportSshPublicKeyRequestT = Model::ImportSshPublicKeyRequest>
  Model::ImportSshPublicKeyOutcomeCallable ImportSshPublicKeyCallable(const ImportSshPublicKeyRequestT& request) const {
    return SubmitCallable(&TransferClient::ImportSshPublicKey, request);
  }
 
  template <typename ImportSshPublicKeyRequestT = Model::ImportSshPublicKeyRequest>
  void ImportSshPublicKeyAsync(const ImportSshPublicKeyRequestT& request, const ImportSshPublicKeyResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::ImportSshPublicKey, request, handler, context);
  }
 
  virtual Model::ListAccessesOutcome ListAccesses(const Model::ListAccessesRequest& request) const;
 
  template <typename ListAccessesRequestT = Model::ListAccessesRequest>
  Model::ListAccessesOutcomeCallable ListAccessesCallable(const ListAccessesRequestT& request) const {
    return SubmitCallable(&TransferClient::ListAccesses, request);
  }
 
  template <typename ListAccessesRequestT = Model::ListAccessesRequest>
  void ListAccessesAsync(const ListAccessesRequestT& request, const ListAccessesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::ListAccesses, request, handler, context);
  }
 
  virtual Model::ListAgreementsOutcome ListAgreements(const Model::ListAgreementsRequest& request) const;
 
  template <typename ListAgreementsRequestT = Model::ListAgreementsRequest>
  Model::ListAgreementsOutcomeCallable ListAgreementsCallable(const ListAgreementsRequestT& request) const {
    return SubmitCallable(&TransferClient::ListAgreements, request);
  }
 
  template <typename ListAgreementsRequestT = Model::ListAgreementsRequest>
  void ListAgreementsAsync(const ListAgreementsRequestT& request, const ListAgreementsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::ListAgreements, request, handler, context);
  }
 
  virtual Model::ListCertificatesOutcome ListCertificates(const Model::ListCertificatesRequest& request = {}) const;
 
  template <typename ListCertificatesRequestT = Model::ListCertificatesRequest>
  Model::ListCertificatesOutcomeCallable ListCertificatesCallable(const ListCertificatesRequestT& request = {}) const {
    return SubmitCallable(&TransferClient::ListCertificates, request);
  }
 
  template <typename ListCertificatesRequestT = Model::ListCertificatesRequest>
  void ListCertificatesAsync(const ListCertificatesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListCertificatesRequestT& request = {}) const {
    return SubmitAsync(&TransferClient::ListCertificates, request, handler, context);
  }
 
  virtual Model::ListConnectorsOutcome ListConnectors(const Model::ListConnectorsRequest& request = {}) const;
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  Model::ListConnectorsOutcomeCallable ListConnectorsCallable(const ListConnectorsRequestT& request = {}) const {
    return SubmitCallable(&TransferClient::ListConnectors, request);
  }
 
  template <typename ListConnectorsRequestT = Model::ListConnectorsRequest>
  void ListConnectorsAsync(const ListConnectorsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListConnectorsRequestT& request = {}) const {
    return SubmitAsync(&TransferClient::ListConnectors, request, handler, context);
  }
 
  virtual Model::ListExecutionsOutcome ListExecutions(const Model::ListExecutionsRequest& request) const;
 
  template <typename ListExecutionsRequestT = Model::ListExecutionsRequest>
  Model::ListExecutionsOutcomeCallable ListExecutionsCallable(const ListExecutionsRequestT& request) const {
    return SubmitCallable(&TransferClient::ListExecutions, request);
  }
 
  template <typename ListExecutionsRequestT = Model::ListExecutionsRequest>
  void ListExecutionsAsync(const ListExecutionsRequestT& request, const ListExecutionsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::ListExecutions, request, handler, context);
  }
 
  virtual Model::ListFileTransferResultsOutcome ListFileTransferResults(const Model::ListFileTransferResultsRequest& request) const;
 
  template <typename ListFileTransferResultsRequestT = Model::ListFileTransferResultsRequest>
  Model::ListFileTransferResultsOutcomeCallable ListFileTransferResultsCallable(const ListFileTransferResultsRequestT& request) const {
    return SubmitCallable(&TransferClient::ListFileTransferResults, request);
  }
 
  template <typename ListFileTransferResultsRequestT = Model::ListFileTransferResultsRequest>
  void ListFileTransferResultsAsync(const ListFileTransferResultsRequestT& request,
                                    const ListFileTransferResultsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::ListFileTransferResults, request, handler, context);
  }
 
  virtual Model::ListHostKeysOutcome ListHostKeys(const Model::ListHostKeysRequest& request) const;
 
  template <typename ListHostKeysRequestT = Model::ListHostKeysRequest>
  Model::ListHostKeysOutcomeCallable ListHostKeysCallable(const ListHostKeysRequestT& request) const {
    return SubmitCallable(&TransferClient::ListHostKeys, request);
  }
 
  template <typename ListHostKeysRequestT = Model::ListHostKeysRequest>
  void ListHostKeysAsync(const ListHostKeysRequestT& request, const ListHostKeysResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::ListHostKeys, request, handler, context);
  }
 
  virtual Model::ListProfilesOutcome ListProfiles(const Model::ListProfilesRequest& request = {}) const;
 
  template <typename ListProfilesRequestT = Model::ListProfilesRequest>
  Model::ListProfilesOutcomeCallable ListProfilesCallable(const ListProfilesRequestT& request = {}) const {
    return SubmitCallable(&TransferClient::ListProfiles, request);
  }
 
  template <typename ListProfilesRequestT = Model::ListProfilesRequest>
  void ListProfilesAsync(const ListProfilesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListProfilesRequestT& request = {}) const {
    return SubmitAsync(&TransferClient::ListProfiles, request, handler, context);
  }
 
  virtual Model::ListSecurityPoliciesOutcome ListSecurityPolicies(const Model::ListSecurityPoliciesRequest& request = {}) const;
 
  template <typename ListSecurityPoliciesRequestT = Model::ListSecurityPoliciesRequest>
  Model::ListSecurityPoliciesOutcomeCallable ListSecurityPoliciesCallable(const ListSecurityPoliciesRequestT& request = {}) const {
    return SubmitCallable(&TransferClient::ListSecurityPolicies, request);
  }
 
  template <typename ListSecurityPoliciesRequestT = Model::ListSecurityPoliciesRequest>
  void ListSecurityPoliciesAsync(const ListSecurityPoliciesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListSecurityPoliciesRequestT& request = {}) const {
    return SubmitAsync(&TransferClient::ListSecurityPolicies, request, handler, context);
  }
 
  virtual Model::ListServersOutcome ListServers(const Model::ListServersRequest& request = {}) const;
 
  template <typename ListServersRequestT = Model::ListServersRequest>
  Model::ListServersOutcomeCallable ListServersCallable(const ListServersRequestT& request = {}) const {
    return SubmitCallable(&TransferClient::ListServers, request);
  }
 
  template <typename ListServersRequestT = Model::ListServersRequest>
  void ListServersAsync(const ListServersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListServersRequestT& request = {}) const {
    return SubmitAsync(&TransferClient::ListServers, 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(&TransferClient::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(&TransferClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const {
    return SubmitCallable(&TransferClient::ListUsers, request);
  }
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::ListUsers, request, handler, context);
  }
 
  virtual Model::ListWebAppsOutcome ListWebApps(const Model::ListWebAppsRequest& request = {}) const;
 
  template <typename ListWebAppsRequestT = Model::ListWebAppsRequest>
  Model::ListWebAppsOutcomeCallable ListWebAppsCallable(const ListWebAppsRequestT& request = {}) const {
    return SubmitCallable(&TransferClient::ListWebApps, request);
  }
 
  template <typename ListWebAppsRequestT = Model::ListWebAppsRequest>
  void ListWebAppsAsync(const ListWebAppsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListWebAppsRequestT& request = {}) const {
    return SubmitAsync(&TransferClient::ListWebApps, request, handler, context);
  }
 
  virtual Model::ListWorkflowsOutcome ListWorkflows(const Model::ListWorkflowsRequest& request = {}) const;
 
  template <typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
  Model::ListWorkflowsOutcomeCallable ListWorkflowsCallable(const ListWorkflowsRequestT& request = {}) const {
    return SubmitCallable(&TransferClient::ListWorkflows, request);
  }
 
  template <typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
  void ListWorkflowsAsync(const ListWorkflowsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListWorkflowsRequestT& request = {}) const {
    return SubmitAsync(&TransferClient::ListWorkflows, request, handler, context);
  }
 
  virtual Model::SendWorkflowStepStateOutcome SendWorkflowStepState(const Model::SendWorkflowStepStateRequest& request) const;
 
  template <typename SendWorkflowStepStateRequestT = Model::SendWorkflowStepStateRequest>
  Model::SendWorkflowStepStateOutcomeCallable SendWorkflowStepStateCallable(const SendWorkflowStepStateRequestT& request) const {
    return SubmitCallable(&TransferClient::SendWorkflowStepState, request);
  }
 
  template <typename SendWorkflowStepStateRequestT = Model::SendWorkflowStepStateRequest>
  void SendWorkflowStepStateAsync(const SendWorkflowStepStateRequestT& request, const SendWorkflowStepStateResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::SendWorkflowStepState, request, handler, context);
  }
 
  virtual Model::StartDirectoryListingOutcome StartDirectoryListing(const Model::StartDirectoryListingRequest& request) const;
 
  template <typename StartDirectoryListingRequestT = Model::StartDirectoryListingRequest>
  Model::StartDirectoryListingOutcomeCallable StartDirectoryListingCallable(const StartDirectoryListingRequestT& request) const {
    return SubmitCallable(&TransferClient::StartDirectoryListing, request);
  }
 
  template <typename StartDirectoryListingRequestT = Model::StartDirectoryListingRequest>
  void StartDirectoryListingAsync(const StartDirectoryListingRequestT& request, const StartDirectoryListingResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::StartDirectoryListing, request, handler, context);
  }
 
  virtual Model::StartFileTransferOutcome StartFileTransfer(const Model::StartFileTransferRequest& request) const;
 
  template <typename StartFileTransferRequestT = Model::StartFileTransferRequest>
  Model::StartFileTransferOutcomeCallable StartFileTransferCallable(const StartFileTransferRequestT& request) const {
    return SubmitCallable(&TransferClient::StartFileTransfer, request);
  }
 
  template <typename StartFileTransferRequestT = Model::StartFileTransferRequest>
  void StartFileTransferAsync(const StartFileTransferRequestT& request, const StartFileTransferResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::StartFileTransfer, request, handler, context);
  }
 
  virtual Model::StartRemoteDeleteOutcome StartRemoteDelete(const Model::StartRemoteDeleteRequest& request) const;
 
  template <typename StartRemoteDeleteRequestT = Model::StartRemoteDeleteRequest>
  Model::StartRemoteDeleteOutcomeCallable StartRemoteDeleteCallable(const StartRemoteDeleteRequestT& request) const {
    return SubmitCallable(&TransferClient::StartRemoteDelete, request);
  }
 
  template <typename StartRemoteDeleteRequestT = Model::StartRemoteDeleteRequest>
  void StartRemoteDeleteAsync(const StartRemoteDeleteRequestT& request, const StartRemoteDeleteResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::StartRemoteDelete, request, handler, context);
  }
 
  virtual Model::StartRemoteMoveOutcome StartRemoteMove(const Model::StartRemoteMoveRequest& request) const;
 
  template <typename StartRemoteMoveRequestT = Model::StartRemoteMoveRequest>
  Model::StartRemoteMoveOutcomeCallable StartRemoteMoveCallable(const StartRemoteMoveRequestT& request) const {
    return SubmitCallable(&TransferClient::StartRemoteMove, request);
  }
 
  template <typename StartRemoteMoveRequestT = Model::StartRemoteMoveRequest>
  void StartRemoteMoveAsync(const StartRemoteMoveRequestT& request, const StartRemoteMoveResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::StartRemoteMove, request, handler, context);
  }
 
  virtual Model::StartServerOutcome StartServer(const Model::StartServerRequest& request) const;
 
  template <typename StartServerRequestT = Model::StartServerRequest>
  Model::StartServerOutcomeCallable StartServerCallable(const StartServerRequestT& request) const {
    return SubmitCallable(&TransferClient::StartServer, request);
  }
 
  template <typename StartServerRequestT = Model::StartServerRequest>
  void StartServerAsync(const StartServerRequestT& request, const StartServerResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::StartServer, request, handler, context);
  }
 
  virtual Model::StopServerOutcome StopServer(const Model::StopServerRequest& request) const;
 
  template <typename StopServerRequestT = Model::StopServerRequest>
  Model::StopServerOutcomeCallable StopServerCallable(const StopServerRequestT& request) const {
    return SubmitCallable(&TransferClient::StopServer, request);
  }
 
  template <typename StopServerRequestT = Model::StopServerRequest>
  void StopServerAsync(const StopServerRequestT& request, const StopServerResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::StopServer, 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(&TransferClient::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(&TransferClient::TagResource, request, handler, context);
  }
 
  virtual Model::TestConnectionOutcome TestConnection(const Model::TestConnectionRequest& request) const;
 
  template <typename TestConnectionRequestT = Model::TestConnectionRequest>
  Model::TestConnectionOutcomeCallable TestConnectionCallable(const TestConnectionRequestT& request) const {
    return SubmitCallable(&TransferClient::TestConnection, request);
  }
 
  template <typename TestConnectionRequestT = Model::TestConnectionRequest>
  void TestConnectionAsync(const TestConnectionRequestT& request, const TestConnectionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::TestConnection, request, handler, context);
  }
 
  virtual Model::TestIdentityProviderOutcome TestIdentityProvider(const Model::TestIdentityProviderRequest& request) const;
 
  template <typename TestIdentityProviderRequestT = Model::TestIdentityProviderRequest>
  Model::TestIdentityProviderOutcomeCallable TestIdentityProviderCallable(const TestIdentityProviderRequestT& request) const {
    return SubmitCallable(&TransferClient::TestIdentityProvider, request);
  }
 
  template <typename TestIdentityProviderRequestT = Model::TestIdentityProviderRequest>
  void TestIdentityProviderAsync(const TestIdentityProviderRequestT& request, const TestIdentityProviderResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::TestIdentityProvider, 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(&TransferClient::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(&TransferClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAccessOutcome UpdateAccess(const Model::UpdateAccessRequest& request) const;
 
  template <typename UpdateAccessRequestT = Model::UpdateAccessRequest>
  Model::UpdateAccessOutcomeCallable UpdateAccessCallable(const UpdateAccessRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateAccess, request);
  }
 
  template <typename UpdateAccessRequestT = Model::UpdateAccessRequest>
  void UpdateAccessAsync(const UpdateAccessRequestT& request, const UpdateAccessResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateAccess, request, handler, context);
  }
 
  virtual Model::UpdateAgreementOutcome UpdateAgreement(const Model::UpdateAgreementRequest& request) const;
 
  template <typename UpdateAgreementRequestT = Model::UpdateAgreementRequest>
  Model::UpdateAgreementOutcomeCallable UpdateAgreementCallable(const UpdateAgreementRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateAgreement, request);
  }
 
  template <typename UpdateAgreementRequestT = Model::UpdateAgreementRequest>
  void UpdateAgreementAsync(const UpdateAgreementRequestT& request, const UpdateAgreementResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateAgreement, request, handler, context);
  }
 
  virtual Model::UpdateCertificateOutcome UpdateCertificate(const Model::UpdateCertificateRequest& request) const;
 
  template <typename UpdateCertificateRequestT = Model::UpdateCertificateRequest>
  Model::UpdateCertificateOutcomeCallable UpdateCertificateCallable(const UpdateCertificateRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateCertificate, request);
  }
 
  template <typename UpdateCertificateRequestT = Model::UpdateCertificateRequest>
  void UpdateCertificateAsync(const UpdateCertificateRequestT& request, const UpdateCertificateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateCertificate, request, handler, context);
  }
 
  virtual Model::UpdateConnectorOutcome UpdateConnector(const Model::UpdateConnectorRequest& request) const;
 
  template <typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
  Model::UpdateConnectorOutcomeCallable UpdateConnectorCallable(const UpdateConnectorRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateConnector, request);
  }
 
  template <typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
  void UpdateConnectorAsync(const UpdateConnectorRequestT& request, const UpdateConnectorResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateConnector, request, handler, context);
  }
 
  virtual Model::UpdateHostKeyOutcome UpdateHostKey(const Model::UpdateHostKeyRequest& request) const;
 
  template <typename UpdateHostKeyRequestT = Model::UpdateHostKeyRequest>
  Model::UpdateHostKeyOutcomeCallable UpdateHostKeyCallable(const UpdateHostKeyRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateHostKey, request);
  }
 
  template <typename UpdateHostKeyRequestT = Model::UpdateHostKeyRequest>
  void UpdateHostKeyAsync(const UpdateHostKeyRequestT& request, const UpdateHostKeyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateHostKey, request, handler, context);
  }
 
  virtual Model::UpdateProfileOutcome UpdateProfile(const Model::UpdateProfileRequest& request) const;
 
  template <typename UpdateProfileRequestT = Model::UpdateProfileRequest>
  Model::UpdateProfileOutcomeCallable UpdateProfileCallable(const UpdateProfileRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateProfile, request);
  }
 
  template <typename UpdateProfileRequestT = Model::UpdateProfileRequest>
  void UpdateProfileAsync(const UpdateProfileRequestT& request, const UpdateProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateProfile, request, handler, context);
  }
 
  virtual Model::UpdateServerOutcome UpdateServer(const Model::UpdateServerRequest& request) const;
 
  template <typename UpdateServerRequestT = Model::UpdateServerRequest>
  Model::UpdateServerOutcomeCallable UpdateServerCallable(const UpdateServerRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateServer, request);
  }
 
  template <typename UpdateServerRequestT = Model::UpdateServerRequest>
  void UpdateServerAsync(const UpdateServerRequestT& request, const UpdateServerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateServer, request, handler, context);
  }
 
  virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const;
 
  template <typename UpdateUserRequestT = Model::UpdateUserRequest>
  Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateUser, request);
  }
 
  template <typename UpdateUserRequestT = Model::UpdateUserRequest>
  void UpdateUserAsync(const UpdateUserRequestT& request, const UpdateUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateUser, request, handler, context);
  }
 
  virtual Model::UpdateWebAppOutcome UpdateWebApp(const Model::UpdateWebAppRequest& request) const;
 
  template <typename UpdateWebAppRequestT = Model::UpdateWebAppRequest>
  Model::UpdateWebAppOutcomeCallable UpdateWebAppCallable(const UpdateWebAppRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateWebApp, request);
  }
 
  template <typename UpdateWebAppRequestT = Model::UpdateWebAppRequest>
  void UpdateWebAppAsync(const UpdateWebAppRequestT& request, const UpdateWebAppResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateWebApp, request, handler, context);
  }
 
  virtual Model::UpdateWebAppCustomizationOutcome UpdateWebAppCustomization(const Model::UpdateWebAppCustomizationRequest& request) const;
 
  template <typename UpdateWebAppCustomizationRequestT = Model::UpdateWebAppCustomizationRequest>
  Model::UpdateWebAppCustomizationOutcomeCallable UpdateWebAppCustomizationCallable(
      const UpdateWebAppCustomizationRequestT& request) const {
    return SubmitCallable(&TransferClient::UpdateWebAppCustomization, request);
  }
 
  template <typename UpdateWebAppCustomizationRequestT = Model::UpdateWebAppCustomizationRequest>
  void UpdateWebAppCustomizationAsync(const UpdateWebAppCustomizationRequestT& request,
                                      const UpdateWebAppCustomizationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TransferClient::UpdateWebAppCustomization, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<TransferEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<TransferClient>;
  void init(const TransferClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, TransferError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  TransferClientConfiguration m_clientConfiguration;
  std::shared_ptr<TransferEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Transfer
}  // namespace Aws