TransferClient.h

 
#pragma once
#include <aws/awstransfer/Transfer_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/awstransfer/TransferServiceClientModel.h>
 
namespace Aws
{
namespace Transfer
{
  class AWS_TRANSFER_API TransferClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<TransferEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<TransferClient>;
      void init(const TransferClientConfiguration& clientConfiguration);
 
      TransferClientConfiguration m_clientConfiguration;
      std::shared_ptr<TransferEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Transfer
} // namespace Aws