DirectConnectClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/directconnect/DirectConnectPaginationBase.h>
#include <aws/directconnect/DirectConnectServiceClientModel.h>
#include <aws/directconnect/DirectConnectWaiter.h>
#include <aws/directconnect/DirectConnect_EXPORTS.h>
 
namespace Aws {
namespace DirectConnect {
class AWS_DIRECTCONNECT_API DirectConnectClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<DirectConnectClient>,
                                                  public DirectConnectPaginationBase<DirectConnectClient>,
                                                  public DirectConnectWaiter<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::AssociateConnectionsToResiliencyGroupOutcome AssociateConnectionsToResiliencyGroup(
      const Model::AssociateConnectionsToResiliencyGroupRequest& request) const;
 
  template <typename AssociateConnectionsToResiliencyGroupRequestT = Model::AssociateConnectionsToResiliencyGroupRequest>
  Model::AssociateConnectionsToResiliencyGroupOutcomeCallable AssociateConnectionsToResiliencyGroupCallable(
      const AssociateConnectionsToResiliencyGroupRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AssociateConnectionsToResiliencyGroup, request);
  }
 
  template <typename AssociateConnectionsToResiliencyGroupRequestT = Model::AssociateConnectionsToResiliencyGroupRequest>
  void AssociateConnectionsToResiliencyGroupAsync(const AssociateConnectionsToResiliencyGroupRequestT& request,
                                                  const AssociateConnectionsToResiliencyGroupResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectConnectClient::AssociateConnectionsToResiliencyGroup, 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::CreateResiliencyGroupOutcome CreateResiliencyGroup(const Model::CreateResiliencyGroupRequest& request) const;
 
  template <typename CreateResiliencyGroupRequestT = Model::CreateResiliencyGroupRequest>
  Model::CreateResiliencyGroupOutcomeCallable CreateResiliencyGroupCallable(const CreateResiliencyGroupRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreateResiliencyGroup, request);
  }
 
  template <typename CreateResiliencyGroupRequestT = Model::CreateResiliencyGroupRequest>
  void CreateResiliencyGroupAsync(const CreateResiliencyGroupRequestT& request, const CreateResiliencyGroupResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectConnectClient::CreateResiliencyGroup, 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::DeleteResiliencyGroupOutcome DeleteResiliencyGroup(const Model::DeleteResiliencyGroupRequest& request) const;
 
  template <typename DeleteResiliencyGroupRequestT = Model::DeleteResiliencyGroupRequest>
  Model::DeleteResiliencyGroupOutcomeCallable DeleteResiliencyGroupCallable(const DeleteResiliencyGroupRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DeleteResiliencyGroup, request);
  }
 
  template <typename DeleteResiliencyGroupRequestT = Model::DeleteResiliencyGroupRequest>
  void DeleteResiliencyGroupAsync(const DeleteResiliencyGroupRequestT& request, const DeleteResiliencyGroupResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectConnectClient::DeleteResiliencyGroup, 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::DisassociateConnectionsFromResiliencyGroupOutcome DisassociateConnectionsFromResiliencyGroup(
      const Model::DisassociateConnectionsFromResiliencyGroupRequest& request) const;
 
  template <typename DisassociateConnectionsFromResiliencyGroupRequestT = Model::DisassociateConnectionsFromResiliencyGroupRequest>
  Model::DisassociateConnectionsFromResiliencyGroupOutcomeCallable DisassociateConnectionsFromResiliencyGroupCallable(
      const DisassociateConnectionsFromResiliencyGroupRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DisassociateConnectionsFromResiliencyGroup, request);
  }
 
  template <typename DisassociateConnectionsFromResiliencyGroupRequestT = Model::DisassociateConnectionsFromResiliencyGroupRequest>
  void DisassociateConnectionsFromResiliencyGroupAsync(
      const DisassociateConnectionsFromResiliencyGroupRequestT& request,
      const DisassociateConnectionsFromResiliencyGroupResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectConnectClient::DisassociateConnectionsFromResiliencyGroup, 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::GetResiliencyGroupOutcome GetResiliencyGroup(const Model::GetResiliencyGroupRequest& request) const;
 
  template <typename GetResiliencyGroupRequestT = Model::GetResiliencyGroupRequest>
  Model::GetResiliencyGroupOutcomeCallable GetResiliencyGroupCallable(const GetResiliencyGroupRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::GetResiliencyGroup, request);
  }
 
  template <typename GetResiliencyGroupRequestT = Model::GetResiliencyGroupRequest>
  void GetResiliencyGroupAsync(const GetResiliencyGroupRequestT& request, const GetResiliencyGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectConnectClient::GetResiliencyGroup, request, handler, context);
  }
 
  virtual Model::ListResiliencyGroupAssociationsOutcome ListResiliencyGroupAssociations(
      const Model::ListResiliencyGroupAssociationsRequest& request) const;
 
  template <typename ListResiliencyGroupAssociationsRequestT = Model::ListResiliencyGroupAssociationsRequest>
  Model::ListResiliencyGroupAssociationsOutcomeCallable ListResiliencyGroupAssociationsCallable(
      const ListResiliencyGroupAssociationsRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::ListResiliencyGroupAssociations, request);
  }
 
  template <typename ListResiliencyGroupAssociationsRequestT = Model::ListResiliencyGroupAssociationsRequest>
  void ListResiliencyGroupAssociationsAsync(const ListResiliencyGroupAssociationsRequestT& request,
                                            const ListResiliencyGroupAssociationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectConnectClient::ListResiliencyGroupAssociations, request, handler, context);
  }
 
  virtual Model::ListResiliencyGroupsOutcome ListResiliencyGroups(const Model::ListResiliencyGroupsRequest& request = {}) const;
 
  template <typename ListResiliencyGroupsRequestT = Model::ListResiliencyGroupsRequest>
  Model::ListResiliencyGroupsOutcomeCallable ListResiliencyGroupsCallable(const ListResiliencyGroupsRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::ListResiliencyGroups, request);
  }
 
  template <typename ListResiliencyGroupsRequestT = Model::ListResiliencyGroupsRequest>
  void ListResiliencyGroupsAsync(const ListResiliencyGroupsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListResiliencyGroupsRequestT& request = {}) const {
    return SubmitAsync(&DirectConnectClient::ListResiliencyGroups, request, handler, context);
  }
 
  virtual Model::ListVirtualInterfaceRoutesOutcome ListVirtualInterfaceRoutes(
      const Model::ListVirtualInterfaceRoutesRequest& request = {}) const;
 
  template <typename ListVirtualInterfaceRoutesRequestT = Model::ListVirtualInterfaceRoutesRequest>
  Model::ListVirtualInterfaceRoutesOutcomeCallable ListVirtualInterfaceRoutesCallable(
      const ListVirtualInterfaceRoutesRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::ListVirtualInterfaceRoutes, request);
  }
 
  template <typename ListVirtualInterfaceRoutesRequestT = Model::ListVirtualInterfaceRoutesRequest>
  void ListVirtualInterfaceRoutesAsync(const ListVirtualInterfaceRoutesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListVirtualInterfaceRoutesRequestT& request = {}) const {
    return SubmitAsync(&DirectConnectClient::ListVirtualInterfaceRoutes, 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::UpdateConnectionsBillingModeOutcome UpdateConnectionsBillingMode(
      const Model::UpdateConnectionsBillingModeRequest& request) const;
 
  template <typename UpdateConnectionsBillingModeRequestT = Model::UpdateConnectionsBillingModeRequest>
  Model::UpdateConnectionsBillingModeOutcomeCallable UpdateConnectionsBillingModeCallable(
      const UpdateConnectionsBillingModeRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::UpdateConnectionsBillingMode, request);
  }
 
  template <typename UpdateConnectionsBillingModeRequestT = Model::UpdateConnectionsBillingModeRequest>
  void UpdateConnectionsBillingModeAsync(const UpdateConnectionsBillingModeRequestT& request,
                                         const UpdateConnectionsBillingModeResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectConnectClient::UpdateConnectionsBillingMode, 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::UpdateResiliencyGroupOutcome UpdateResiliencyGroup(const Model::UpdateResiliencyGroupRequest& request) const;
 
  template <typename UpdateResiliencyGroupRequestT = Model::UpdateResiliencyGroupRequest>
  Model::UpdateResiliencyGroupOutcomeCallable UpdateResiliencyGroupCallable(const UpdateResiliencyGroupRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::UpdateResiliencyGroup, request);
  }
 
  template <typename UpdateResiliencyGroupRequestT = Model::UpdateResiliencyGroupRequest>
  void UpdateResiliencyGroupAsync(const UpdateResiliencyGroupRequestT& request, const UpdateResiliencyGroupResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DirectConnectClient::UpdateResiliencyGroup, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DirectConnectEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DirectConnectClient>;
  void init(const DirectConnectClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DirectConnectError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  DirectConnectClientConfiguration m_clientConfiguration;
  std::shared_ptr<DirectConnectEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DirectConnect
}  // namespace Aws