DirectConnectClient.h

 
#pragma once
#include <aws/directconnect/DirectConnect_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/directconnect/DirectConnectServiceClientModel.h>
 
namespace Aws
{
namespace DirectConnect
{
  class AWS_DIRECTCONNECT_API DirectConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<DirectConnectClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef DirectConnectClientConfiguration ClientConfigurationType;
      typedef DirectConnectEndpointProvider EndpointProviderType;
 
        DirectConnectClient(const Aws::DirectConnect::DirectConnectClientConfiguration& clientConfiguration = Aws::DirectConnect::DirectConnectClientConfiguration(),
                            std::shared_ptr<DirectConnectEndpointProviderBase> endpointProvider = nullptr);
 
        DirectConnectClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<DirectConnectEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::DirectConnect::DirectConnectClientConfiguration& clientConfiguration = Aws::DirectConnect::DirectConnectClientConfiguration());
 
        DirectConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<DirectConnectEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::DirectConnect::DirectConnectClientConfiguration& clientConfiguration = Aws::DirectConnect::DirectConnectClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        DirectConnectClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DirectConnectClient(const Aws::Auth::AWSCredentials& credentials,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        DirectConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~DirectConnectClient();
 
        virtual Model::AcceptDirectConnectGatewayAssociationProposalOutcome AcceptDirectConnectGatewayAssociationProposal(const Model::AcceptDirectConnectGatewayAssociationProposalRequest& request) const;
 
        template<typename AcceptDirectConnectGatewayAssociationProposalRequestT = Model::AcceptDirectConnectGatewayAssociationProposalRequest>
        Model::AcceptDirectConnectGatewayAssociationProposalOutcomeCallable AcceptDirectConnectGatewayAssociationProposalCallable(const AcceptDirectConnectGatewayAssociationProposalRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::AcceptDirectConnectGatewayAssociationProposal, request);
        }
 
        template<typename AcceptDirectConnectGatewayAssociationProposalRequestT = Model::AcceptDirectConnectGatewayAssociationProposalRequest>
        void AcceptDirectConnectGatewayAssociationProposalAsync(const AcceptDirectConnectGatewayAssociationProposalRequestT& request, const AcceptDirectConnectGatewayAssociationProposalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::AcceptDirectConnectGatewayAssociationProposal, request, handler, context);
        }
 
        virtual Model::AllocateHostedConnectionOutcome AllocateHostedConnection(const Model::AllocateHostedConnectionRequest& request) const;
 
        template<typename AllocateHostedConnectionRequestT = Model::AllocateHostedConnectionRequest>
        Model::AllocateHostedConnectionOutcomeCallable AllocateHostedConnectionCallable(const AllocateHostedConnectionRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::AllocateHostedConnection, request);
        }
 
        template<typename AllocateHostedConnectionRequestT = Model::AllocateHostedConnectionRequest>
        void AllocateHostedConnectionAsync(const AllocateHostedConnectionRequestT& request, const AllocateHostedConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::AllocateHostedConnection, request, handler, context);
        }
 
        virtual Model::AllocatePrivateVirtualInterfaceOutcome AllocatePrivateVirtualInterface(const Model::AllocatePrivateVirtualInterfaceRequest& request) const;
 
        template<typename AllocatePrivateVirtualInterfaceRequestT = Model::AllocatePrivateVirtualInterfaceRequest>
        Model::AllocatePrivateVirtualInterfaceOutcomeCallable AllocatePrivateVirtualInterfaceCallable(const AllocatePrivateVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::AllocatePrivateVirtualInterface, request);
        }
 
        template<typename AllocatePrivateVirtualInterfaceRequestT = Model::AllocatePrivateVirtualInterfaceRequest>
        void AllocatePrivateVirtualInterfaceAsync(const AllocatePrivateVirtualInterfaceRequestT& request, const AllocatePrivateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::AllocatePrivateVirtualInterface, request, handler, context);
        }
 
        virtual Model::AllocatePublicVirtualInterfaceOutcome AllocatePublicVirtualInterface(const Model::AllocatePublicVirtualInterfaceRequest& request) const;
 
        template<typename AllocatePublicVirtualInterfaceRequestT = Model::AllocatePublicVirtualInterfaceRequest>
        Model::AllocatePublicVirtualInterfaceOutcomeCallable AllocatePublicVirtualInterfaceCallable(const AllocatePublicVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::AllocatePublicVirtualInterface, request);
        }
 
        template<typename AllocatePublicVirtualInterfaceRequestT = Model::AllocatePublicVirtualInterfaceRequest>
        void AllocatePublicVirtualInterfaceAsync(const AllocatePublicVirtualInterfaceRequestT& request, const AllocatePublicVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::AllocatePublicVirtualInterface, request, handler, context);
        }
 
        virtual Model::AllocateTransitVirtualInterfaceOutcome AllocateTransitVirtualInterface(const Model::AllocateTransitVirtualInterfaceRequest& request) const;
 
        template<typename AllocateTransitVirtualInterfaceRequestT = Model::AllocateTransitVirtualInterfaceRequest>
        Model::AllocateTransitVirtualInterfaceOutcomeCallable AllocateTransitVirtualInterfaceCallable(const AllocateTransitVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::AllocateTransitVirtualInterface, request);
        }
 
        template<typename AllocateTransitVirtualInterfaceRequestT = Model::AllocateTransitVirtualInterfaceRequest>
        void AllocateTransitVirtualInterfaceAsync(const AllocateTransitVirtualInterfaceRequestT& request, const AllocateTransitVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::AllocateTransitVirtualInterface, request, handler, context);
        }
 
        virtual Model::AssociateConnectionWithLagOutcome AssociateConnectionWithLag(const Model::AssociateConnectionWithLagRequest& request) const;
 
        template<typename AssociateConnectionWithLagRequestT = Model::AssociateConnectionWithLagRequest>
        Model::AssociateConnectionWithLagOutcomeCallable AssociateConnectionWithLagCallable(const AssociateConnectionWithLagRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::AssociateConnectionWithLag, request);
        }
 
        template<typename AssociateConnectionWithLagRequestT = Model::AssociateConnectionWithLagRequest>
        void AssociateConnectionWithLagAsync(const AssociateConnectionWithLagRequestT& request, const AssociateConnectionWithLagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::AssociateConnectionWithLag, request, handler, context);
        }
 
        virtual Model::AssociateHostedConnectionOutcome AssociateHostedConnection(const Model::AssociateHostedConnectionRequest& request) const;
 
        template<typename AssociateHostedConnectionRequestT = Model::AssociateHostedConnectionRequest>
        Model::AssociateHostedConnectionOutcomeCallable AssociateHostedConnectionCallable(const AssociateHostedConnectionRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::AssociateHostedConnection, request);
        }
 
        template<typename AssociateHostedConnectionRequestT = Model::AssociateHostedConnectionRequest>
        void AssociateHostedConnectionAsync(const AssociateHostedConnectionRequestT& request, const AssociateHostedConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::AssociateHostedConnection, request, handler, context);
        }
 
        virtual Model::AssociateMacSecKeyOutcome AssociateMacSecKey(const Model::AssociateMacSecKeyRequest& request) const;
 
        template<typename AssociateMacSecKeyRequestT = Model::AssociateMacSecKeyRequest>
        Model::AssociateMacSecKeyOutcomeCallable AssociateMacSecKeyCallable(const AssociateMacSecKeyRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::AssociateMacSecKey, request);
        }
 
        template<typename AssociateMacSecKeyRequestT = Model::AssociateMacSecKeyRequest>
        void AssociateMacSecKeyAsync(const AssociateMacSecKeyRequestT& request, const AssociateMacSecKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::AssociateMacSecKey, request, handler, context);
        }
 
        virtual Model::AssociateVirtualInterfaceOutcome AssociateVirtualInterface(const Model::AssociateVirtualInterfaceRequest& request) const;
 
        template<typename AssociateVirtualInterfaceRequestT = Model::AssociateVirtualInterfaceRequest>
        Model::AssociateVirtualInterfaceOutcomeCallable AssociateVirtualInterfaceCallable(const AssociateVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::AssociateVirtualInterface, request);
        }
 
        template<typename AssociateVirtualInterfaceRequestT = Model::AssociateVirtualInterfaceRequest>
        void AssociateVirtualInterfaceAsync(const AssociateVirtualInterfaceRequestT& request, const AssociateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::AssociateVirtualInterface, request, handler, context);
        }
 
        virtual Model::ConfirmConnectionOutcome ConfirmConnection(const Model::ConfirmConnectionRequest& request) const;
 
        template<typename ConfirmConnectionRequestT = Model::ConfirmConnectionRequest>
        Model::ConfirmConnectionOutcomeCallable ConfirmConnectionCallable(const ConfirmConnectionRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::ConfirmConnection, request);
        }
 
        template<typename ConfirmConnectionRequestT = Model::ConfirmConnectionRequest>
        void ConfirmConnectionAsync(const ConfirmConnectionRequestT& request, const ConfirmConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::ConfirmConnection, request, handler, context);
        }
 
        virtual Model::ConfirmCustomerAgreementOutcome ConfirmCustomerAgreement(const Model::ConfirmCustomerAgreementRequest& request = {}) const;
 
        template<typename ConfirmCustomerAgreementRequestT = Model::ConfirmCustomerAgreementRequest>
        Model::ConfirmCustomerAgreementOutcomeCallable ConfirmCustomerAgreementCallable(const ConfirmCustomerAgreementRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::ConfirmCustomerAgreement, request);
        }
 
        template<typename ConfirmCustomerAgreementRequestT = Model::ConfirmCustomerAgreementRequest>
        void ConfirmCustomerAgreementAsync(const ConfirmCustomerAgreementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ConfirmCustomerAgreementRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::ConfirmCustomerAgreement, request, handler, context);
        }
 
        virtual Model::ConfirmPrivateVirtualInterfaceOutcome ConfirmPrivateVirtualInterface(const Model::ConfirmPrivateVirtualInterfaceRequest& request) const;
 
        template<typename ConfirmPrivateVirtualInterfaceRequestT = Model::ConfirmPrivateVirtualInterfaceRequest>
        Model::ConfirmPrivateVirtualInterfaceOutcomeCallable ConfirmPrivateVirtualInterfaceCallable(const ConfirmPrivateVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::ConfirmPrivateVirtualInterface, request);
        }
 
        template<typename ConfirmPrivateVirtualInterfaceRequestT = Model::ConfirmPrivateVirtualInterfaceRequest>
        void ConfirmPrivateVirtualInterfaceAsync(const ConfirmPrivateVirtualInterfaceRequestT& request, const ConfirmPrivateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::ConfirmPrivateVirtualInterface, request, handler, context);
        }
 
        virtual Model::ConfirmPublicVirtualInterfaceOutcome ConfirmPublicVirtualInterface(const Model::ConfirmPublicVirtualInterfaceRequest& request) const;
 
        template<typename ConfirmPublicVirtualInterfaceRequestT = Model::ConfirmPublicVirtualInterfaceRequest>
        Model::ConfirmPublicVirtualInterfaceOutcomeCallable ConfirmPublicVirtualInterfaceCallable(const ConfirmPublicVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::ConfirmPublicVirtualInterface, request);
        }
 
        template<typename ConfirmPublicVirtualInterfaceRequestT = Model::ConfirmPublicVirtualInterfaceRequest>
        void ConfirmPublicVirtualInterfaceAsync(const ConfirmPublicVirtualInterfaceRequestT& request, const ConfirmPublicVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::ConfirmPublicVirtualInterface, request, handler, context);
        }
 
        virtual Model::ConfirmTransitVirtualInterfaceOutcome ConfirmTransitVirtualInterface(const Model::ConfirmTransitVirtualInterfaceRequest& request) const;
 
        template<typename ConfirmTransitVirtualInterfaceRequestT = Model::ConfirmTransitVirtualInterfaceRequest>
        Model::ConfirmTransitVirtualInterfaceOutcomeCallable ConfirmTransitVirtualInterfaceCallable(const ConfirmTransitVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::ConfirmTransitVirtualInterface, request);
        }
 
        template<typename ConfirmTransitVirtualInterfaceRequestT = Model::ConfirmTransitVirtualInterfaceRequest>
        void ConfirmTransitVirtualInterfaceAsync(const ConfirmTransitVirtualInterfaceRequestT& request, const ConfirmTransitVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::ConfirmTransitVirtualInterface, request, handler, context);
        }
 
        virtual Model::CreateBGPPeerOutcome CreateBGPPeer(const Model::CreateBGPPeerRequest& request = {}) const;
 
        template<typename CreateBGPPeerRequestT = Model::CreateBGPPeerRequest>
        Model::CreateBGPPeerOutcomeCallable CreateBGPPeerCallable(const CreateBGPPeerRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::CreateBGPPeer, request);
        }
 
        template<typename CreateBGPPeerRequestT = Model::CreateBGPPeerRequest>
        void CreateBGPPeerAsync(const CreateBGPPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateBGPPeerRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::CreateBGPPeer, request, handler, context);
        }
 
        virtual Model::CreateConnectionOutcome CreateConnection(const Model::CreateConnectionRequest& request) const;
 
        template<typename CreateConnectionRequestT = Model::CreateConnectionRequest>
        Model::CreateConnectionOutcomeCallable CreateConnectionCallable(const CreateConnectionRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::CreateConnection, request);
        }
 
        template<typename CreateConnectionRequestT = Model::CreateConnectionRequest>
        void CreateConnectionAsync(const CreateConnectionRequestT& request, const CreateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::CreateConnection, request, handler, context);
        }
 
        virtual Model::CreateDirectConnectGatewayOutcome CreateDirectConnectGateway(const Model::CreateDirectConnectGatewayRequest& request) const;
 
        template<typename CreateDirectConnectGatewayRequestT = Model::CreateDirectConnectGatewayRequest>
        Model::CreateDirectConnectGatewayOutcomeCallable CreateDirectConnectGatewayCallable(const CreateDirectConnectGatewayRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::CreateDirectConnectGateway, request);
        }
 
        template<typename CreateDirectConnectGatewayRequestT = Model::CreateDirectConnectGatewayRequest>
        void CreateDirectConnectGatewayAsync(const CreateDirectConnectGatewayRequestT& request, const CreateDirectConnectGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::CreateDirectConnectGateway, request, handler, context);
        }
 
        virtual Model::CreateDirectConnectGatewayAssociationOutcome CreateDirectConnectGatewayAssociation(const Model::CreateDirectConnectGatewayAssociationRequest& request) const;
 
        template<typename CreateDirectConnectGatewayAssociationRequestT = Model::CreateDirectConnectGatewayAssociationRequest>
        Model::CreateDirectConnectGatewayAssociationOutcomeCallable CreateDirectConnectGatewayAssociationCallable(const CreateDirectConnectGatewayAssociationRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::CreateDirectConnectGatewayAssociation, request);
        }
 
        template<typename CreateDirectConnectGatewayAssociationRequestT = Model::CreateDirectConnectGatewayAssociationRequest>
        void CreateDirectConnectGatewayAssociationAsync(const CreateDirectConnectGatewayAssociationRequestT& request, const CreateDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::CreateDirectConnectGatewayAssociation, request, handler, context);
        }
 
        virtual Model::CreateDirectConnectGatewayAssociationProposalOutcome CreateDirectConnectGatewayAssociationProposal(const Model::CreateDirectConnectGatewayAssociationProposalRequest& request) const;
 
        template<typename CreateDirectConnectGatewayAssociationProposalRequestT = Model::CreateDirectConnectGatewayAssociationProposalRequest>
        Model::CreateDirectConnectGatewayAssociationProposalOutcomeCallable CreateDirectConnectGatewayAssociationProposalCallable(const CreateDirectConnectGatewayAssociationProposalRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::CreateDirectConnectGatewayAssociationProposal, request);
        }
 
        template<typename CreateDirectConnectGatewayAssociationProposalRequestT = Model::CreateDirectConnectGatewayAssociationProposalRequest>
        void CreateDirectConnectGatewayAssociationProposalAsync(const CreateDirectConnectGatewayAssociationProposalRequestT& request, const CreateDirectConnectGatewayAssociationProposalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::CreateDirectConnectGatewayAssociationProposal, request, handler, context);
        }
 
        virtual Model::CreateInterconnectOutcome CreateInterconnect(const Model::CreateInterconnectRequest& request) const;
 
        template<typename CreateInterconnectRequestT = Model::CreateInterconnectRequest>
        Model::CreateInterconnectOutcomeCallable CreateInterconnectCallable(const CreateInterconnectRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::CreateInterconnect, request);
        }
 
        template<typename CreateInterconnectRequestT = Model::CreateInterconnectRequest>
        void CreateInterconnectAsync(const CreateInterconnectRequestT& request, const CreateInterconnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::CreateInterconnect, request, handler, context);
        }
 
        virtual Model::CreateLagOutcome CreateLag(const Model::CreateLagRequest& request) const;
 
        template<typename CreateLagRequestT = Model::CreateLagRequest>
        Model::CreateLagOutcomeCallable CreateLagCallable(const CreateLagRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::CreateLag, request);
        }
 
        template<typename CreateLagRequestT = Model::CreateLagRequest>
        void CreateLagAsync(const CreateLagRequestT& request, const CreateLagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::CreateLag, request, handler, context);
        }
 
        virtual Model::CreatePrivateVirtualInterfaceOutcome CreatePrivateVirtualInterface(const Model::CreatePrivateVirtualInterfaceRequest& request) const;
 
        template<typename CreatePrivateVirtualInterfaceRequestT = Model::CreatePrivateVirtualInterfaceRequest>
        Model::CreatePrivateVirtualInterfaceOutcomeCallable CreatePrivateVirtualInterfaceCallable(const CreatePrivateVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::CreatePrivateVirtualInterface, request);
        }
 
        template<typename CreatePrivateVirtualInterfaceRequestT = Model::CreatePrivateVirtualInterfaceRequest>
        void CreatePrivateVirtualInterfaceAsync(const CreatePrivateVirtualInterfaceRequestT& request, const CreatePrivateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::CreatePrivateVirtualInterface, request, handler, context);
        }
 
        virtual Model::CreatePublicVirtualInterfaceOutcome CreatePublicVirtualInterface(const Model::CreatePublicVirtualInterfaceRequest& request) const;
 
        template<typename CreatePublicVirtualInterfaceRequestT = Model::CreatePublicVirtualInterfaceRequest>
        Model::CreatePublicVirtualInterfaceOutcomeCallable CreatePublicVirtualInterfaceCallable(const CreatePublicVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::CreatePublicVirtualInterface, request);
        }
 
        template<typename CreatePublicVirtualInterfaceRequestT = Model::CreatePublicVirtualInterfaceRequest>
        void CreatePublicVirtualInterfaceAsync(const CreatePublicVirtualInterfaceRequestT& request, const CreatePublicVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::CreatePublicVirtualInterface, request, handler, context);
        }
 
        virtual Model::CreateTransitVirtualInterfaceOutcome CreateTransitVirtualInterface(const Model::CreateTransitVirtualInterfaceRequest& request) const;
 
        template<typename CreateTransitVirtualInterfaceRequestT = Model::CreateTransitVirtualInterfaceRequest>
        Model::CreateTransitVirtualInterfaceOutcomeCallable CreateTransitVirtualInterfaceCallable(const CreateTransitVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::CreateTransitVirtualInterface, request);
        }
 
        template<typename CreateTransitVirtualInterfaceRequestT = Model::CreateTransitVirtualInterfaceRequest>
        void CreateTransitVirtualInterfaceAsync(const CreateTransitVirtualInterfaceRequestT& request, const CreateTransitVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::CreateTransitVirtualInterface, request, handler, context);
        }
 
        virtual Model::DeleteBGPPeerOutcome DeleteBGPPeer(const Model::DeleteBGPPeerRequest& request = {}) const;
 
        template<typename DeleteBGPPeerRequestT = Model::DeleteBGPPeerRequest>
        Model::DeleteBGPPeerOutcomeCallable DeleteBGPPeerCallable(const DeleteBGPPeerRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DeleteBGPPeer, request);
        }
 
        template<typename DeleteBGPPeerRequestT = Model::DeleteBGPPeerRequest>
        void DeleteBGPPeerAsync(const DeleteBGPPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteBGPPeerRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DeleteBGPPeer, request, handler, context);
        }
 
        virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const;
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const DeleteConnectionRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DeleteConnection, request);
        }
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        void DeleteConnectionAsync(const DeleteConnectionRequestT& request, const DeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DeleteConnection, request, handler, context);
        }
 
        virtual Model::DeleteDirectConnectGatewayOutcome DeleteDirectConnectGateway(const Model::DeleteDirectConnectGatewayRequest& request) const;
 
        template<typename DeleteDirectConnectGatewayRequestT = Model::DeleteDirectConnectGatewayRequest>
        Model::DeleteDirectConnectGatewayOutcomeCallable DeleteDirectConnectGatewayCallable(const DeleteDirectConnectGatewayRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DeleteDirectConnectGateway, request);
        }
 
        template<typename DeleteDirectConnectGatewayRequestT = Model::DeleteDirectConnectGatewayRequest>
        void DeleteDirectConnectGatewayAsync(const DeleteDirectConnectGatewayRequestT& request, const DeleteDirectConnectGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DeleteDirectConnectGateway, request, handler, context);
        }
 
        virtual Model::DeleteDirectConnectGatewayAssociationOutcome DeleteDirectConnectGatewayAssociation(const Model::DeleteDirectConnectGatewayAssociationRequest& request = {}) const;
 
        template<typename DeleteDirectConnectGatewayAssociationRequestT = Model::DeleteDirectConnectGatewayAssociationRequest>
        Model::DeleteDirectConnectGatewayAssociationOutcomeCallable DeleteDirectConnectGatewayAssociationCallable(const DeleteDirectConnectGatewayAssociationRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DeleteDirectConnectGatewayAssociation, request);
        }
 
        template<typename DeleteDirectConnectGatewayAssociationRequestT = Model::DeleteDirectConnectGatewayAssociationRequest>
        void DeleteDirectConnectGatewayAssociationAsync(const DeleteDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteDirectConnectGatewayAssociationRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DeleteDirectConnectGatewayAssociation, request, handler, context);
        }
 
        virtual Model::DeleteDirectConnectGatewayAssociationProposalOutcome DeleteDirectConnectGatewayAssociationProposal(const Model::DeleteDirectConnectGatewayAssociationProposalRequest& request) const;
 
        template<typename DeleteDirectConnectGatewayAssociationProposalRequestT = Model::DeleteDirectConnectGatewayAssociationProposalRequest>
        Model::DeleteDirectConnectGatewayAssociationProposalOutcomeCallable DeleteDirectConnectGatewayAssociationProposalCallable(const DeleteDirectConnectGatewayAssociationProposalRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DeleteDirectConnectGatewayAssociationProposal, request);
        }
 
        template<typename DeleteDirectConnectGatewayAssociationProposalRequestT = Model::DeleteDirectConnectGatewayAssociationProposalRequest>
        void DeleteDirectConnectGatewayAssociationProposalAsync(const DeleteDirectConnectGatewayAssociationProposalRequestT& request, const DeleteDirectConnectGatewayAssociationProposalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DeleteDirectConnectGatewayAssociationProposal, request, handler, context);
        }
 
        virtual Model::DeleteInterconnectOutcome DeleteInterconnect(const Model::DeleteInterconnectRequest& request) const;
 
        template<typename DeleteInterconnectRequestT = Model::DeleteInterconnectRequest>
        Model::DeleteInterconnectOutcomeCallable DeleteInterconnectCallable(const DeleteInterconnectRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DeleteInterconnect, request);
        }
 
        template<typename DeleteInterconnectRequestT = Model::DeleteInterconnectRequest>
        void DeleteInterconnectAsync(const DeleteInterconnectRequestT& request, const DeleteInterconnectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DeleteInterconnect, request, handler, context);
        }
 
        virtual Model::DeleteLagOutcome DeleteLag(const Model::DeleteLagRequest& request) const;
 
        template<typename DeleteLagRequestT = Model::DeleteLagRequest>
        Model::DeleteLagOutcomeCallable DeleteLagCallable(const DeleteLagRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DeleteLag, request);
        }
 
        template<typename DeleteLagRequestT = Model::DeleteLagRequest>
        void DeleteLagAsync(const DeleteLagRequestT& request, const DeleteLagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DeleteLag, request, handler, context);
        }
 
        virtual Model::DeleteVirtualInterfaceOutcome DeleteVirtualInterface(const Model::DeleteVirtualInterfaceRequest& request) const;
 
        template<typename DeleteVirtualInterfaceRequestT = Model::DeleteVirtualInterfaceRequest>
        Model::DeleteVirtualInterfaceOutcomeCallable DeleteVirtualInterfaceCallable(const DeleteVirtualInterfaceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DeleteVirtualInterface, request);
        }
 
        template<typename DeleteVirtualInterfaceRequestT = Model::DeleteVirtualInterfaceRequest>
        void DeleteVirtualInterfaceAsync(const DeleteVirtualInterfaceRequestT& request, const DeleteVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DeleteVirtualInterface, request, handler, context);
        }
 
        virtual Model::DescribeConnectionsOutcome DescribeConnections(const Model::DescribeConnectionsRequest& request = {}) const;
 
        template<typename DescribeConnectionsRequestT = Model::DescribeConnectionsRequest>
        Model::DescribeConnectionsOutcomeCallable DescribeConnectionsCallable(const DescribeConnectionsRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeConnections, request);
        }
 
        template<typename DescribeConnectionsRequestT = Model::DescribeConnectionsRequest>
        void DescribeConnectionsAsync(const DescribeConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeConnectionsRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeConnections, request, handler, context);
        }
 
        virtual Model::DescribeCustomerMetadataOutcome DescribeCustomerMetadata(const Model::DescribeCustomerMetadataRequest& request = {}) const;
 
        template<typename DescribeCustomerMetadataRequestT = Model::DescribeCustomerMetadataRequest>
        Model::DescribeCustomerMetadataOutcomeCallable DescribeCustomerMetadataCallable(const DescribeCustomerMetadataRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeCustomerMetadata, request);
        }
 
        template<typename DescribeCustomerMetadataRequestT = Model::DescribeCustomerMetadataRequest>
        void DescribeCustomerMetadataAsync(const DescribeCustomerMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCustomerMetadataRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeCustomerMetadata, request, handler, context);
        }
 
        virtual Model::DescribeDirectConnectGatewayAssociationProposalsOutcome DescribeDirectConnectGatewayAssociationProposals(const Model::DescribeDirectConnectGatewayAssociationProposalsRequest& request = {}) const;
 
        template<typename DescribeDirectConnectGatewayAssociationProposalsRequestT = Model::DescribeDirectConnectGatewayAssociationProposalsRequest>
        Model::DescribeDirectConnectGatewayAssociationProposalsOutcomeCallable DescribeDirectConnectGatewayAssociationProposalsCallable(const DescribeDirectConnectGatewayAssociationProposalsRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeDirectConnectGatewayAssociationProposals, request);
        }
 
        template<typename DescribeDirectConnectGatewayAssociationProposalsRequestT = Model::DescribeDirectConnectGatewayAssociationProposalsRequest>
        void DescribeDirectConnectGatewayAssociationProposalsAsync(const DescribeDirectConnectGatewayAssociationProposalsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDirectConnectGatewayAssociationProposalsRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeDirectConnectGatewayAssociationProposals, request, handler, context);
        }
 
        virtual Model::DescribeDirectConnectGatewayAssociationsOutcome DescribeDirectConnectGatewayAssociations(const Model::DescribeDirectConnectGatewayAssociationsRequest& request = {}) const;
 
        template<typename DescribeDirectConnectGatewayAssociationsRequestT = Model::DescribeDirectConnectGatewayAssociationsRequest>
        Model::DescribeDirectConnectGatewayAssociationsOutcomeCallable DescribeDirectConnectGatewayAssociationsCallable(const DescribeDirectConnectGatewayAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeDirectConnectGatewayAssociations, request);
        }
 
        template<typename DescribeDirectConnectGatewayAssociationsRequestT = Model::DescribeDirectConnectGatewayAssociationsRequest>
        void DescribeDirectConnectGatewayAssociationsAsync(const DescribeDirectConnectGatewayAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDirectConnectGatewayAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeDirectConnectGatewayAssociations, request, handler, context);
        }
 
        virtual Model::DescribeDirectConnectGatewayAttachmentsOutcome DescribeDirectConnectGatewayAttachments(const Model::DescribeDirectConnectGatewayAttachmentsRequest& request = {}) const;
 
        template<typename DescribeDirectConnectGatewayAttachmentsRequestT = Model::DescribeDirectConnectGatewayAttachmentsRequest>
        Model::DescribeDirectConnectGatewayAttachmentsOutcomeCallable DescribeDirectConnectGatewayAttachmentsCallable(const DescribeDirectConnectGatewayAttachmentsRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeDirectConnectGatewayAttachments, request);
        }
 
        template<typename DescribeDirectConnectGatewayAttachmentsRequestT = Model::DescribeDirectConnectGatewayAttachmentsRequest>
        void DescribeDirectConnectGatewayAttachmentsAsync(const DescribeDirectConnectGatewayAttachmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDirectConnectGatewayAttachmentsRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeDirectConnectGatewayAttachments, request, handler, context);
        }
 
        virtual Model::DescribeDirectConnectGatewaysOutcome DescribeDirectConnectGateways(const Model::DescribeDirectConnectGatewaysRequest& request = {}) const;
 
        template<typename DescribeDirectConnectGatewaysRequestT = Model::DescribeDirectConnectGatewaysRequest>
        Model::DescribeDirectConnectGatewaysOutcomeCallable DescribeDirectConnectGatewaysCallable(const DescribeDirectConnectGatewaysRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeDirectConnectGateways, request);
        }
 
        template<typename DescribeDirectConnectGatewaysRequestT = Model::DescribeDirectConnectGatewaysRequest>
        void DescribeDirectConnectGatewaysAsync(const DescribeDirectConnectGatewaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDirectConnectGatewaysRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeDirectConnectGateways, request, handler, context);
        }
 
        virtual Model::DescribeHostedConnectionsOutcome DescribeHostedConnections(const Model::DescribeHostedConnectionsRequest& request) const;
 
        template<typename DescribeHostedConnectionsRequestT = Model::DescribeHostedConnectionsRequest>
        Model::DescribeHostedConnectionsOutcomeCallable DescribeHostedConnectionsCallable(const DescribeHostedConnectionsRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeHostedConnections, request);
        }
 
        template<typename DescribeHostedConnectionsRequestT = Model::DescribeHostedConnectionsRequest>
        void DescribeHostedConnectionsAsync(const DescribeHostedConnectionsRequestT& request, const DescribeHostedConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeHostedConnections, request, handler, context);
        }
 
        virtual Model::DescribeInterconnectsOutcome DescribeInterconnects(const Model::DescribeInterconnectsRequest& request = {}) const;
 
        template<typename DescribeInterconnectsRequestT = Model::DescribeInterconnectsRequest>
        Model::DescribeInterconnectsOutcomeCallable DescribeInterconnectsCallable(const DescribeInterconnectsRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeInterconnects, request);
        }
 
        template<typename DescribeInterconnectsRequestT = Model::DescribeInterconnectsRequest>
        void DescribeInterconnectsAsync(const DescribeInterconnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeInterconnectsRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeInterconnects, request, handler, context);
        }
 
        virtual Model::DescribeLagsOutcome DescribeLags(const Model::DescribeLagsRequest& request = {}) const;
 
        template<typename DescribeLagsRequestT = Model::DescribeLagsRequest>
        Model::DescribeLagsOutcomeCallable DescribeLagsCallable(const DescribeLagsRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeLags, request);
        }
 
        template<typename DescribeLagsRequestT = Model::DescribeLagsRequest>
        void DescribeLagsAsync(const DescribeLagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLagsRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeLags, request, handler, context);
        }
 
        virtual Model::DescribeLoaOutcome DescribeLoa(const Model::DescribeLoaRequest& request) const;
 
        template<typename DescribeLoaRequestT = Model::DescribeLoaRequest>
        Model::DescribeLoaOutcomeCallable DescribeLoaCallable(const DescribeLoaRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeLoa, request);
        }
 
        template<typename DescribeLoaRequestT = Model::DescribeLoaRequest>
        void DescribeLoaAsync(const DescribeLoaRequestT& request, const DescribeLoaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeLoa, request, handler, context);
        }
 
        virtual Model::DescribeLocationsOutcome DescribeLocations(const Model::DescribeLocationsRequest& request = {}) const;
 
        template<typename DescribeLocationsRequestT = Model::DescribeLocationsRequest>
        Model::DescribeLocationsOutcomeCallable DescribeLocationsCallable(const DescribeLocationsRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeLocations, request);
        }
 
        template<typename DescribeLocationsRequestT = Model::DescribeLocationsRequest>
        void DescribeLocationsAsync(const DescribeLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLocationsRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeLocations, request, handler, context);
        }
 
        virtual Model::DescribeRouterConfigurationOutcome DescribeRouterConfiguration(const Model::DescribeRouterConfigurationRequest& request) const;
 
        template<typename DescribeRouterConfigurationRequestT = Model::DescribeRouterConfigurationRequest>
        Model::DescribeRouterConfigurationOutcomeCallable DescribeRouterConfigurationCallable(const DescribeRouterConfigurationRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeRouterConfiguration, request);
        }
 
        template<typename DescribeRouterConfigurationRequestT = Model::DescribeRouterConfigurationRequest>
        void DescribeRouterConfigurationAsync(const DescribeRouterConfigurationRequestT& request, const DescribeRouterConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeRouterConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const;
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeTags, request);
        }
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        void DescribeTagsAsync(const DescribeTagsRequestT& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeTags, request, handler, context);
        }
 
        virtual Model::DescribeVirtualGatewaysOutcome DescribeVirtualGateways(const Model::DescribeVirtualGatewaysRequest& request = {}) const;
 
        template<typename DescribeVirtualGatewaysRequestT = Model::DescribeVirtualGatewaysRequest>
        Model::DescribeVirtualGatewaysOutcomeCallable DescribeVirtualGatewaysCallable(const DescribeVirtualGatewaysRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeVirtualGateways, request);
        }
 
        template<typename DescribeVirtualGatewaysRequestT = Model::DescribeVirtualGatewaysRequest>
        void DescribeVirtualGatewaysAsync(const DescribeVirtualGatewaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeVirtualGatewaysRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeVirtualGateways, request, handler, context);
        }
 
        virtual Model::DescribeVirtualInterfacesOutcome DescribeVirtualInterfaces(const Model::DescribeVirtualInterfacesRequest& request = {}) const;
 
        template<typename DescribeVirtualInterfacesRequestT = Model::DescribeVirtualInterfacesRequest>
        Model::DescribeVirtualInterfacesOutcomeCallable DescribeVirtualInterfacesCallable(const DescribeVirtualInterfacesRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::DescribeVirtualInterfaces, request);
        }
 
        template<typename DescribeVirtualInterfacesRequestT = Model::DescribeVirtualInterfacesRequest>
        void DescribeVirtualInterfacesAsync(const DescribeVirtualInterfacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeVirtualInterfacesRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::DescribeVirtualInterfaces, request, handler, context);
        }
 
        virtual Model::DisassociateConnectionFromLagOutcome DisassociateConnectionFromLag(const Model::DisassociateConnectionFromLagRequest& request) const;
 
        template<typename DisassociateConnectionFromLagRequestT = Model::DisassociateConnectionFromLagRequest>
        Model::DisassociateConnectionFromLagOutcomeCallable DisassociateConnectionFromLagCallable(const DisassociateConnectionFromLagRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DisassociateConnectionFromLag, request);
        }
 
        template<typename DisassociateConnectionFromLagRequestT = Model::DisassociateConnectionFromLagRequest>
        void DisassociateConnectionFromLagAsync(const DisassociateConnectionFromLagRequestT& request, const DisassociateConnectionFromLagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DisassociateConnectionFromLag, request, handler, context);
        }
 
        virtual Model::DisassociateMacSecKeyOutcome DisassociateMacSecKey(const Model::DisassociateMacSecKeyRequest& request) const;
 
        template<typename DisassociateMacSecKeyRequestT = Model::DisassociateMacSecKeyRequest>
        Model::DisassociateMacSecKeyOutcomeCallable DisassociateMacSecKeyCallable(const DisassociateMacSecKeyRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::DisassociateMacSecKey, request);
        }
 
        template<typename DisassociateMacSecKeyRequestT = Model::DisassociateMacSecKeyRequest>
        void DisassociateMacSecKeyAsync(const DisassociateMacSecKeyRequestT& request, const DisassociateMacSecKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::DisassociateMacSecKey, request, handler, context);
        }
 
        virtual Model::ListVirtualInterfaceTestHistoryOutcome ListVirtualInterfaceTestHistory(const Model::ListVirtualInterfaceTestHistoryRequest& request = {}) const;
 
        template<typename ListVirtualInterfaceTestHistoryRequestT = Model::ListVirtualInterfaceTestHistoryRequest>
        Model::ListVirtualInterfaceTestHistoryOutcomeCallable ListVirtualInterfaceTestHistoryCallable(const ListVirtualInterfaceTestHistoryRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::ListVirtualInterfaceTestHistory, request);
        }
 
        template<typename ListVirtualInterfaceTestHistoryRequestT = Model::ListVirtualInterfaceTestHistoryRequest>
        void ListVirtualInterfaceTestHistoryAsync(const ListVirtualInterfaceTestHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVirtualInterfaceTestHistoryRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::ListVirtualInterfaceTestHistory, request, handler, context);
        }
 
        virtual Model::StartBgpFailoverTestOutcome StartBgpFailoverTest(const Model::StartBgpFailoverTestRequest& request) const;
 
        template<typename StartBgpFailoverTestRequestT = Model::StartBgpFailoverTestRequest>
        Model::StartBgpFailoverTestOutcomeCallable StartBgpFailoverTestCallable(const StartBgpFailoverTestRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::StartBgpFailoverTest, request);
        }
 
        template<typename StartBgpFailoverTestRequestT = Model::StartBgpFailoverTestRequest>
        void StartBgpFailoverTestAsync(const StartBgpFailoverTestRequestT& request, const StartBgpFailoverTestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::StartBgpFailoverTest, request, handler, context);
        }
 
        virtual Model::StopBgpFailoverTestOutcome StopBgpFailoverTest(const Model::StopBgpFailoverTestRequest& request) const;
 
        template<typename StopBgpFailoverTestRequestT = Model::StopBgpFailoverTestRequest>
        Model::StopBgpFailoverTestOutcomeCallable StopBgpFailoverTestCallable(const StopBgpFailoverTestRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::StopBgpFailoverTest, request);
        }
 
        template<typename StopBgpFailoverTestRequestT = Model::StopBgpFailoverTestRequest>
        void StopBgpFailoverTestAsync(const StopBgpFailoverTestRequestT& request, const StopBgpFailoverTestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::StopBgpFailoverTest, 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(&DirectConnectClient::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(&DirectConnectClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::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(&DirectConnectClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateConnectionOutcome UpdateConnection(const Model::UpdateConnectionRequest& request) const;
 
        template<typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
        Model::UpdateConnectionOutcomeCallable UpdateConnectionCallable(const UpdateConnectionRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::UpdateConnection, request);
        }
 
        template<typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
        void UpdateConnectionAsync(const UpdateConnectionRequestT& request, const UpdateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::UpdateConnection, request, handler, context);
        }
 
        virtual Model::UpdateDirectConnectGatewayOutcome UpdateDirectConnectGateway(const Model::UpdateDirectConnectGatewayRequest& request) const;
 
        template<typename UpdateDirectConnectGatewayRequestT = Model::UpdateDirectConnectGatewayRequest>
        Model::UpdateDirectConnectGatewayOutcomeCallable UpdateDirectConnectGatewayCallable(const UpdateDirectConnectGatewayRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::UpdateDirectConnectGateway, request);
        }
 
        template<typename UpdateDirectConnectGatewayRequestT = Model::UpdateDirectConnectGatewayRequest>
        void UpdateDirectConnectGatewayAsync(const UpdateDirectConnectGatewayRequestT& request, const UpdateDirectConnectGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::UpdateDirectConnectGateway, request, handler, context);
        }
 
        virtual Model::UpdateDirectConnectGatewayAssociationOutcome UpdateDirectConnectGatewayAssociation(const Model::UpdateDirectConnectGatewayAssociationRequest& request = {}) const;
 
        template<typename UpdateDirectConnectGatewayAssociationRequestT = Model::UpdateDirectConnectGatewayAssociationRequest>
        Model::UpdateDirectConnectGatewayAssociationOutcomeCallable UpdateDirectConnectGatewayAssociationCallable(const UpdateDirectConnectGatewayAssociationRequestT& request = {}) const
        {
            return SubmitCallable(&DirectConnectClient::UpdateDirectConnectGatewayAssociation, request);
        }
 
        template<typename UpdateDirectConnectGatewayAssociationRequestT = Model::UpdateDirectConnectGatewayAssociationRequest>
        void UpdateDirectConnectGatewayAssociationAsync(const UpdateDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateDirectConnectGatewayAssociationRequestT& request = {}) const
        {
            return SubmitAsync(&DirectConnectClient::UpdateDirectConnectGatewayAssociation, request, handler, context);
        }
 
        virtual Model::UpdateLagOutcome UpdateLag(const Model::UpdateLagRequest& request) const;
 
        template<typename UpdateLagRequestT = Model::UpdateLagRequest>
        Model::UpdateLagOutcomeCallable UpdateLagCallable(const UpdateLagRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::UpdateLag, request);
        }
 
        template<typename UpdateLagRequestT = Model::UpdateLagRequest>
        void UpdateLagAsync(const UpdateLagRequestT& request, const UpdateLagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::UpdateLag, request, handler, context);
        }
 
        virtual Model::UpdateVirtualInterfaceAttributesOutcome UpdateVirtualInterfaceAttributes(const Model::UpdateVirtualInterfaceAttributesRequest& request) const;
 
        template<typename UpdateVirtualInterfaceAttributesRequestT = Model::UpdateVirtualInterfaceAttributesRequest>
        Model::UpdateVirtualInterfaceAttributesOutcomeCallable UpdateVirtualInterfaceAttributesCallable(const UpdateVirtualInterfaceAttributesRequestT& request) const
        {
            return SubmitCallable(&DirectConnectClient::UpdateVirtualInterfaceAttributes, request);
        }
 
        template<typename UpdateVirtualInterfaceAttributesRequestT = Model::UpdateVirtualInterfaceAttributesRequest>
        void UpdateVirtualInterfaceAttributesAsync(const UpdateVirtualInterfaceAttributesRequestT& request, const UpdateVirtualInterfaceAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&DirectConnectClient::UpdateVirtualInterfaceAttributes, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<DirectConnectEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<DirectConnectClient>;
      void init(const DirectConnectClientConfiguration& clientConfiguration);
 
      DirectConnectClientConfiguration m_clientConfiguration;
      std::shared_ptr<DirectConnectEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace DirectConnect
} // namespace Aws