/**
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * SPDX-License-Identifier: Apache-2.0.
 */

#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/DirectConnectServiceClientModel.h>
#include <aws/directconnect/DirectConnect_EXPORTS.h>

namespace Aws {
namespace DirectConnect {
/**
 * <p>Direct Connect links your internal network to an Direct Connect location over
 * a standard Ethernet fiber-optic cable. One end of the cable is connected to your
 * router, the other to an Direct Connect router. With this connection in place,
 * you can create virtual interfaces directly to the Amazon Web Services Cloud (for
 * example, to Amazon EC2 and Amazon S3) and to Amazon VPC, bypassing Internet
 * service providers in your network path. A connection provides access to all
 * Amazon Web Services Regions except the China (Beijing) and (China) Ningxia
 * Regions. Amazon Web Services resources in the China Regions can only be accessed
 * through locations associated with those Regions.</p>
 */
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;

  /**
   * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client
   * config is not specified, it will be initialized to default values.
   */
  DirectConnectClient(const Aws::DirectConnect::DirectConnectClientConfiguration& clientConfiguration =
                          Aws::DirectConnect::DirectConnectClientConfiguration(),
                      std::shared_ptr<DirectConnectEndpointProviderBase> endpointProvider = nullptr);

  /**
   * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
   * is not specified, it will be initialized to default values.
   */
  DirectConnectClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<DirectConnectEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::DirectConnect::DirectConnectClientConfiguration& clientConfiguration =
                          Aws::DirectConnect::DirectConnectClientConfiguration());

  /**
   * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
   * the default http client factory will be used
   */
  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 */
  /**
   * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client
   * config is not specified, it will be initialized to default values.
   */
  DirectConnectClient(const Aws::Client::ClientConfiguration& clientConfiguration);

  /**
   * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
   * is not specified, it will be initialized to default values.
   */
  DirectConnectClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);

  /**
   * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
   * the default http client factory will be used
   */
  DirectConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);

  /* End of legacy constructors due deprecation */
  virtual ~DirectConnectClient();

  /**
   * <p>Accepts a proposal request to attach a virtual private gateway or transit
   * gateway to a Direct Connect gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AcceptDirectConnectGatewayAssociationProposal">AWS
   * API Reference</a></p>
   */
  virtual Model::AcceptDirectConnectGatewayAssociationProposalOutcome AcceptDirectConnectGatewayAssociationProposal(
      const Model::AcceptDirectConnectGatewayAssociationProposalRequest& request) const;

  /**
   * A Callable wrapper for AcceptDirectConnectGatewayAssociationProposal that returns a future to the operation so that it can be executed
   * in parallel to other requests.
   */
  template <typename AcceptDirectConnectGatewayAssociationProposalRequestT = Model::AcceptDirectConnectGatewayAssociationProposalRequest>
  Model::AcceptDirectConnectGatewayAssociationProposalOutcomeCallable AcceptDirectConnectGatewayAssociationProposalCallable(
      const AcceptDirectConnectGatewayAssociationProposalRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AcceptDirectConnectGatewayAssociationProposal, request);
  }

  /**
   * An Async wrapper for AcceptDirectConnectGatewayAssociationProposal that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a hosted connection on the specified interconnect or a link
   * aggregation group (LAG) of interconnects.</p> <p>Allocates a VLAN number and a
   * specified amount of capacity (bandwidth) for use by a hosted connection on the
   * specified interconnect or LAG of interconnects. Amazon Web Services polices the
   * hosted connection for the specified capacity and the Direct Connect Partner must
   * also police the hosted connection for the specified capacity.</p>
   * <p>Intended for use by Direct Connect Partners only.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AllocateHostedConnection">AWS
   * API Reference</a></p>
   */
  virtual Model::AllocateHostedConnectionOutcome AllocateHostedConnection(const Model::AllocateHostedConnectionRequest& request) const;

  /**
   * A Callable wrapper for AllocateHostedConnection that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AllocateHostedConnectionRequestT = Model::AllocateHostedConnectionRequest>
  Model::AllocateHostedConnectionOutcomeCallable AllocateHostedConnectionCallable(const AllocateHostedConnectionRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AllocateHostedConnection, request);
  }

  /**
   * An Async wrapper for AllocateHostedConnection that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Provisions a private virtual interface to be owned by the specified Amazon
   * Web Services account.</p> <p>Virtual interfaces created using this action must
   * be confirmed by the owner using <a>ConfirmPrivateVirtualInterface</a>. Until
   * then, the virtual interface is in the <code>Confirming</code> state and is not
   * available to handle traffic.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AllocatePrivateVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::AllocatePrivateVirtualInterfaceOutcome AllocatePrivateVirtualInterface(
      const Model::AllocatePrivateVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for AllocatePrivateVirtualInterface that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename AllocatePrivateVirtualInterfaceRequestT = Model::AllocatePrivateVirtualInterfaceRequest>
  Model::AllocatePrivateVirtualInterfaceOutcomeCallable AllocatePrivateVirtualInterfaceCallable(
      const AllocatePrivateVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AllocatePrivateVirtualInterface, request);
  }

  /**
   * An Async wrapper for AllocatePrivateVirtualInterface that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Provisions a public virtual interface to be owned by the specified Amazon Web
   * Services account.</p> <p>The owner of a connection calls this function to
   * provision a public virtual interface to be owned by the specified Amazon Web
   * Services account.</p> <p>Virtual interfaces created using this function must be
   * confirmed by the owner using <a>ConfirmPublicVirtualInterface</a>. Until this
   * step has been completed, the virtual interface is in the <code>confirming</code>
   * state and is not available to handle traffic.</p> <p>When creating an IPv6
   * public virtual interface, omit the Amazon address and customer address. IPv6
   * addresses are automatically assigned from the Amazon pool of IPv6 addresses; you
   * cannot specify custom IPv6 addresses.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AllocatePublicVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::AllocatePublicVirtualInterfaceOutcome AllocatePublicVirtualInterface(
      const Model::AllocatePublicVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for AllocatePublicVirtualInterface that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename AllocatePublicVirtualInterfaceRequestT = Model::AllocatePublicVirtualInterfaceRequest>
  Model::AllocatePublicVirtualInterfaceOutcomeCallable AllocatePublicVirtualInterfaceCallable(
      const AllocatePublicVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AllocatePublicVirtualInterface, request);
  }

  /**
   * An Async wrapper for AllocatePublicVirtualInterface that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Provisions a transit virtual interface to be owned by the specified Amazon
   * Web Services account. Use this type of interface to connect a transit gateway to
   * your Direct Connect gateway.</p> <p>The owner of a connection provisions a
   * transit virtual interface to be owned by the specified Amazon Web Services
   * account.</p> <p>After you create a transit virtual interface, it must be
   * confirmed by the owner using <a>ConfirmTransitVirtualInterface</a>. Until this
   * step has been completed, the transit virtual interface is in the
   * <code>requested</code> state and is not available to handle
   * traffic.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AllocateTransitVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::AllocateTransitVirtualInterfaceOutcome AllocateTransitVirtualInterface(
      const Model::AllocateTransitVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for AllocateTransitVirtualInterface that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename AllocateTransitVirtualInterfaceRequestT = Model::AllocateTransitVirtualInterfaceRequest>
  Model::AllocateTransitVirtualInterfaceOutcomeCallable AllocateTransitVirtualInterfaceCallable(
      const AllocateTransitVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AllocateTransitVirtualInterface, request);
  }

  /**
   * An Async wrapper for AllocateTransitVirtualInterface that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Associates an existing connection with a link aggregation group (LAG). The
   * connection is interrupted and re-established as a member of the LAG
   * (connectivity to Amazon Web Services is interrupted). The connection must be
   * hosted on the same Direct Connect endpoint as the LAG, and its bandwidth must
   * match the bandwidth for the LAG. You can re-associate a connection that's
   * currently associated with a different LAG; however, if removing the connection
   * would cause the original LAG to fall below its setting for minimum number of
   * operational connections, the request fails.</p> <p>Any virtual interfaces that
   * are directly associated with the connection are automatically re-associated with
   * the LAG. If the connection was originally associated with a different LAG, the
   * virtual interfaces remain associated with the original LAG.</p> <p>For
   * interconnects, any hosted connections are automatically re-associated with the
   * LAG. If the interconnect was originally associated with a different LAG, the
   * hosted connections remain associated with the original LAG.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AssociateConnectionWithLag">AWS
   * API Reference</a></p>
   */
  virtual Model::AssociateConnectionWithLagOutcome AssociateConnectionWithLag(
      const Model::AssociateConnectionWithLagRequest& request) const;

  /**
   * A Callable wrapper for AssociateConnectionWithLag that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename AssociateConnectionWithLagRequestT = Model::AssociateConnectionWithLagRequest>
  Model::AssociateConnectionWithLagOutcomeCallable AssociateConnectionWithLagCallable(
      const AssociateConnectionWithLagRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AssociateConnectionWithLag, request);
  }

  /**
   * An Async wrapper for AssociateConnectionWithLag that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Associates a hosted connection and its virtual interfaces with a link
   * aggregation group (LAG) or interconnect. If the target interconnect or LAG has
   * an existing hosted connection with a conflicting VLAN number or IP address, the
   * operation fails. This action temporarily interrupts the hosted connection's
   * connectivity to Amazon Web Services as it is being migrated.</p>
   * <p>Intended for use by Direct Connect Partners only.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AssociateHostedConnection">AWS
   * API Reference</a></p>
   */
  virtual Model::AssociateHostedConnectionOutcome AssociateHostedConnection(const Model::AssociateHostedConnectionRequest& request) const;

  /**
   * A Callable wrapper for AssociateHostedConnection that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AssociateHostedConnectionRequestT = Model::AssociateHostedConnectionRequest>
  Model::AssociateHostedConnectionOutcomeCallable AssociateHostedConnectionCallable(
      const AssociateHostedConnectionRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AssociateHostedConnection, request);
  }

  /**
   * An Async wrapper for AssociateHostedConnection that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Associates a MAC Security (MACsec) Connection Key Name (CKN)/ Connectivity
   * Association Key (CAK) pair with a Direct Connect connection.</p> <p>You must
   * supply either the <code>secretARN,</code> or the CKN/CAK (<code>ckn</code> and
   * <code>cak</code>) pair in the request.</p> <p>For information about MAC Security
   * (MACsec) key considerations, see <a
   * href="https://docs.aws.amazon.com/directconnect/latest/UserGuide/direct-connect-mac-sec-getting-started.html#mac-sec-key-consideration">MACsec
   * pre-shared CKN/CAK key considerations </a> in the <i>Direct Connect User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AssociateMacSecKey">AWS
   * API Reference</a></p>
   */
  virtual Model::AssociateMacSecKeyOutcome AssociateMacSecKey(const Model::AssociateMacSecKeyRequest& request) const;

  /**
   * A Callable wrapper for AssociateMacSecKey that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AssociateMacSecKeyRequestT = Model::AssociateMacSecKeyRequest>
  Model::AssociateMacSecKeyOutcomeCallable AssociateMacSecKeyCallable(const AssociateMacSecKeyRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AssociateMacSecKey, request);
  }

  /**
   * An Async wrapper for AssociateMacSecKey that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Associates a virtual interface with a specified link aggregation group (LAG)
   * or connection. Connectivity to Amazon Web Services is temporarily interrupted as
   * the virtual interface is being migrated. If the target connection or LAG has an
   * associated virtual interface with a conflicting VLAN number or a conflicting IP
   * address, the operation fails.</p> <p>Virtual interfaces associated with a hosted
   * connection cannot be associated with a LAG; hosted connections must be migrated
   * along with their virtual interfaces using <a>AssociateHostedConnection</a>.</p>
   * <p>To reassociate a virtual interface to a new connection or LAG, the requester
   * must own either the virtual interface itself or the connection to which the
   * virtual interface is currently associated. Additionally, the requester must own
   * the connection or LAG for the association.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/AssociateVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::AssociateVirtualInterfaceOutcome AssociateVirtualInterface(const Model::AssociateVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for AssociateVirtualInterface that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AssociateVirtualInterfaceRequestT = Model::AssociateVirtualInterfaceRequest>
  Model::AssociateVirtualInterfaceOutcomeCallable AssociateVirtualInterfaceCallable(
      const AssociateVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::AssociateVirtualInterface, request);
  }

  /**
   * An Async wrapper for AssociateVirtualInterface that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Confirms the creation of the specified hosted connection on an
   * interconnect.</p> <p>Upon creation, the hosted connection is initially in the
   * <code>Ordering</code> state, and remains in this state until the owner confirms
   * creation of the hosted connection.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/ConfirmConnection">AWS
   * API Reference</a></p>
   */
  virtual Model::ConfirmConnectionOutcome ConfirmConnection(const Model::ConfirmConnectionRequest& request) const;

  /**
   * A Callable wrapper for ConfirmConnection that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ConfirmConnectionRequestT = Model::ConfirmConnectionRequest>
  Model::ConfirmConnectionOutcomeCallable ConfirmConnectionCallable(const ConfirmConnectionRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::ConfirmConnection, request);
  }

  /**
   * An Async wrapper for ConfirmConnection that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p> The confirmation of the terms of agreement when creating the connection/link
   * aggregation group (LAG). </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/ConfirmCustomerAgreement">AWS
   * API Reference</a></p>
   */
  virtual Model::ConfirmCustomerAgreementOutcome ConfirmCustomerAgreement(const Model::ConfirmCustomerAgreementRequest& request = {}) const;

  /**
   * A Callable wrapper for ConfirmCustomerAgreement that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ConfirmCustomerAgreementRequestT = Model::ConfirmCustomerAgreementRequest>
  Model::ConfirmCustomerAgreementOutcomeCallable ConfirmCustomerAgreementCallable(
      const ConfirmCustomerAgreementRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::ConfirmCustomerAgreement, request);
  }

  /**
   * An Async wrapper for ConfirmCustomerAgreement that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Accepts ownership of a private virtual interface created by another Amazon
   * Web Services account.</p> <p>After the virtual interface owner makes this call,
   * the virtual interface is created and attached to the specified virtual private
   * gateway or Direct Connect gateway, and is made available to handle
   * traffic.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/ConfirmPrivateVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::ConfirmPrivateVirtualInterfaceOutcome ConfirmPrivateVirtualInterface(
      const Model::ConfirmPrivateVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for ConfirmPrivateVirtualInterface that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ConfirmPrivateVirtualInterfaceRequestT = Model::ConfirmPrivateVirtualInterfaceRequest>
  Model::ConfirmPrivateVirtualInterfaceOutcomeCallable ConfirmPrivateVirtualInterfaceCallable(
      const ConfirmPrivateVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::ConfirmPrivateVirtualInterface, request);
  }

  /**
   * An Async wrapper for ConfirmPrivateVirtualInterface that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Accepts ownership of a public virtual interface created by another Amazon Web
   * Services account.</p> <p>After the virtual interface owner makes this call, the
   * specified virtual interface is created and made available to handle
   * traffic.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/ConfirmPublicVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::ConfirmPublicVirtualInterfaceOutcome ConfirmPublicVirtualInterface(
      const Model::ConfirmPublicVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for ConfirmPublicVirtualInterface that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ConfirmPublicVirtualInterfaceRequestT = Model::ConfirmPublicVirtualInterfaceRequest>
  Model::ConfirmPublicVirtualInterfaceOutcomeCallable ConfirmPublicVirtualInterfaceCallable(
      const ConfirmPublicVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::ConfirmPublicVirtualInterface, request);
  }

  /**
   * An Async wrapper for ConfirmPublicVirtualInterface that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Accepts ownership of a transit virtual interface created by another Amazon
   * Web Services account.</p> <p> After the owner of the transit virtual interface
   * makes this call, the specified transit virtual interface is created and made
   * available to handle traffic.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/ConfirmTransitVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::ConfirmTransitVirtualInterfaceOutcome ConfirmTransitVirtualInterface(
      const Model::ConfirmTransitVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for ConfirmTransitVirtualInterface that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ConfirmTransitVirtualInterfaceRequestT = Model::ConfirmTransitVirtualInterfaceRequest>
  Model::ConfirmTransitVirtualInterfaceOutcomeCallable ConfirmTransitVirtualInterfaceCallable(
      const ConfirmTransitVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::ConfirmTransitVirtualInterface, request);
  }

  /**
   * An Async wrapper for ConfirmTransitVirtualInterface that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a BGP peer on the specified virtual interface.</p> <p>You must create
   * a BGP peer for the corresponding address family (IPv4/IPv6) in order to access
   * Amazon Web Services resources that also use that address family.</p> <p>If
   * logical redundancy is not supported by the connection, interconnect, or LAG, the
   * BGP peer cannot be in the same address family as an existing BGP peer on the
   * virtual interface.</p> <p>When creating a IPv6 BGP peer, omit the Amazon address
   * and customer address. IPv6 addresses are automatically assigned from the Amazon
   * pool of IPv6 addresses; you cannot specify custom IPv6 addresses.</p>
   *  <p>If you let Amazon Web Services auto-assign IPv4 addresses, a /30
   * CIDR will be allocated from 169.254.0.0/16. Amazon Web Services does not
   * recommend this option if you intend to use the customer router peer IP address
   * as the source and destination for traffic. Instead you should use RFC 1918 or
   * other addressing, and specify the address yourself. For more information about
   * RFC 1918 see <a href="https://datatracker.ietf.org/doc/html/rfc1918"> Address
   * Allocation for Private Internets</a>.</p>  <p>For a public virtual
   * interface, the Autonomous System Number (ASN) must be private or already on the
   * allow list for the virtual interface.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreateBGPPeer">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateBGPPeerOutcome CreateBGPPeer(const Model::CreateBGPPeerRequest& request = {}) const;

  /**
   * A Callable wrapper for CreateBGPPeer that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateBGPPeerRequestT = Model::CreateBGPPeerRequest>
  Model::CreateBGPPeerOutcomeCallable CreateBGPPeerCallable(const CreateBGPPeerRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::CreateBGPPeer, request);
  }

  /**
   * An Async wrapper for CreateBGPPeer that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Creates a connection between a customer network and a specific Direct Connect
   * location.</p> <p>A connection links your internal network to an Direct Connect
   * location over a standard Ethernet fiber-optic cable. One end of the cable is
   * connected to your router, the other to an Direct Connect router.</p> <p>To find
   * the locations for your Region, use <a>DescribeLocations</a>.</p> <p>You can
   * automatically add the new connection to a link aggregation group (LAG) by
   * specifying a LAG ID in the request. This ensures that the new connection is
   * allocated on the same Direct Connect endpoint that hosts the specified LAG. If
   * there are no available ports on the endpoint, the request fails and no
   * connection is created.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreateConnection">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateConnectionOutcome CreateConnection(const Model::CreateConnectionRequest& request) const;

  /**
   * A Callable wrapper for CreateConnection that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateConnectionRequestT = Model::CreateConnectionRequest>
  Model::CreateConnectionOutcomeCallable CreateConnectionCallable(const CreateConnectionRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreateConnection, request);
  }

  /**
   * An Async wrapper for CreateConnection that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Creates a Direct Connect gateway, which is an intermediate object that
   * enables you to connect a set of virtual interfaces and virtual private gateways.
   * A Direct Connect gateway is global and visible in any Amazon Web Services Region
   * after it is created. The virtual interfaces and virtual private gateways that
   * are connected through a Direct Connect gateway can be in different Amazon Web
   * Services Regions. This enables you to connect to a VPC in any Region, regardless
   * of the Region in which the virtual interfaces are located, and pass traffic
   * between them.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreateDirectConnectGateway">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateDirectConnectGatewayOutcome CreateDirectConnectGateway(
      const Model::CreateDirectConnectGatewayRequest& request) const;

  /**
   * A Callable wrapper for CreateDirectConnectGateway that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreateDirectConnectGatewayRequestT = Model::CreateDirectConnectGatewayRequest>
  Model::CreateDirectConnectGatewayOutcomeCallable CreateDirectConnectGatewayCallable(
      const CreateDirectConnectGatewayRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreateDirectConnectGateway, request);
  }

  /**
   * An Async wrapper for CreateDirectConnectGateway that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Creates an association between a Direct Connect gateway and a virtual private
   * gateway. The virtual private gateway must be attached to a VPC and must not be
   * associated with another Direct Connect gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreateDirectConnectGatewayAssociation">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateDirectConnectGatewayAssociationOutcome CreateDirectConnectGatewayAssociation(
      const Model::CreateDirectConnectGatewayAssociationRequest& request) const;

  /**
   * A Callable wrapper for CreateDirectConnectGatewayAssociation that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename CreateDirectConnectGatewayAssociationRequestT = Model::CreateDirectConnectGatewayAssociationRequest>
  Model::CreateDirectConnectGatewayAssociationOutcomeCallable CreateDirectConnectGatewayAssociationCallable(
      const CreateDirectConnectGatewayAssociationRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreateDirectConnectGatewayAssociation, request);
  }

  /**
   * An Async wrapper for CreateDirectConnectGatewayAssociation that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a proposal to associate the specified virtual private gateway or
   * transit gateway with the specified Direct Connect gateway.</p> <p>You can
   * associate a Direct Connect gateway and virtual private gateway or transit
   * gateway that is owned by any Amazon Web Services account. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreateDirectConnectGatewayAssociationProposal">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateDirectConnectGatewayAssociationProposalOutcome CreateDirectConnectGatewayAssociationProposal(
      const Model::CreateDirectConnectGatewayAssociationProposalRequest& request) const;

  /**
   * A Callable wrapper for CreateDirectConnectGatewayAssociationProposal that returns a future to the operation so that it can be executed
   * in parallel to other requests.
   */
  template <typename CreateDirectConnectGatewayAssociationProposalRequestT = Model::CreateDirectConnectGatewayAssociationProposalRequest>
  Model::CreateDirectConnectGatewayAssociationProposalOutcomeCallable CreateDirectConnectGatewayAssociationProposalCallable(
      const CreateDirectConnectGatewayAssociationProposalRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreateDirectConnectGatewayAssociationProposal, request);
  }

  /**
   * An Async wrapper for CreateDirectConnectGatewayAssociationProposal that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Creates an interconnect between an Direct Connect Partner's network and a
   * specific Direct Connect location.</p> <p>An interconnect is a connection that is
   * capable of hosting other connections. The Direct Connect Partner can use an
   * interconnect to provide Direct Connect hosted connections to customers through
   * their own network services. Like a standard connection, an interconnect links
   * the partner's network to an Direct Connect location over a standard Ethernet
   * fiber-optic cable. One end is connected to the partner's router, the other to an
   * Direct Connect router.</p> <p>You can automatically add the new interconnect to
   * a link aggregation group (LAG) by specifying a LAG ID in the request. This
   * ensures that the new interconnect is allocated on the same Direct Connect
   * endpoint that hosts the specified LAG. If there are no available ports on the
   * endpoint, the request fails and no interconnect is created.</p> <p>For each end
   * customer, the Direct Connect Partner provisions a connection on their
   * interconnect by calling <a>AllocateHostedConnection</a>. The end customer can
   * then connect to Amazon Web Services resources by creating a virtual interface on
   * their connection, using the VLAN assigned to them by the Direct Connect
   * Partner.</p>  <p>Intended for use by Direct Connect Partners only.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreateInterconnect">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateInterconnectOutcome CreateInterconnect(const Model::CreateInterconnectRequest& request) const;

  /**
   * A Callable wrapper for CreateInterconnect that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateInterconnectRequestT = Model::CreateInterconnectRequest>
  Model::CreateInterconnectOutcomeCallable CreateInterconnectCallable(const CreateInterconnectRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreateInterconnect, request);
  }

  /**
   * An Async wrapper for CreateInterconnect that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Creates a link aggregation group (LAG) with the specified number of bundled
   * physical dedicated connections between the customer network and a specific
   * Direct Connect location. A LAG is a logical interface that uses the Link
   * Aggregation Control Protocol (LACP) to aggregate multiple interfaces, enabling
   * you to treat them as a single interface.</p> <p>All connections in a LAG must
   * use the same bandwidth (either 1Gbps, 10Gbps, 100Gbps, or 400Gbps) and must
   * terminate at the same Direct Connect endpoint.</p> <p>You can have up to 10
   * dedicated connections per location. Regardless of this limit, if you request
   * more connections for the LAG than Direct Connect can allocate on a single
   * endpoint, no LAG is created..</p> <p>You can specify an existing physical
   * dedicated connection or interconnect to include in the LAG (which counts towards
   * the total number of connections). Doing so interrupts the current physical
   * dedicated connection, and re-establishes them as a member of the LAG. The LAG
   * will be created on the same Direct Connect endpoint to which the dedicated
   * connection terminates. Any virtual interfaces associated with the dedicated
   * connection are automatically disassociated and re-associated with the LAG. The
   * connection ID does not change.</p> <p>If the Amazon Web Services account used to
   * create a LAG is a registered Direct Connect Partner, the LAG is automatically
   * enabled to host sub-connections. For a LAG owned by a partner, any associated
   * virtual interfaces cannot be directly configured.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreateLag">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateLagOutcome CreateLag(const Model::CreateLagRequest& request) const;

  /**
   * A Callable wrapper for CreateLag that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CreateLagRequestT = Model::CreateLagRequest>
  Model::CreateLagOutcomeCallable CreateLagCallable(const CreateLagRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreateLag, request);
  }

  /**
   * An Async wrapper for CreateLag that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Creates a private virtual interface. A virtual interface is the VLAN that
   * transports Direct Connect traffic. A private virtual interface can be connected
   * to either a Direct Connect gateway or a Virtual Private Gateway (VGW).
   * Connecting the private virtual interface to a Direct Connect gateway enables the
   * possibility for connecting to multiple VPCs, including VPCs in different Amazon
   * Web Services Regions. Connecting the private virtual interface to a VGW only
   * provides access to a single VPC within the same Region.</p> <p>Setting the MTU
   * of a virtual interface to 8500 (jumbo frames) can cause an update to the
   * underlying physical connection if it wasn't updated to support jumbo frames.
   * Updating the connection disrupts network connectivity for all virtual interfaces
   * associated with the connection for up to 30 seconds. To check whether your
   * connection supports jumbo frames, call <a>DescribeConnections</a>. To check
   * whether your virtual interface supports jumbo frames, call
   * <a>DescribeVirtualInterfaces</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreatePrivateVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::CreatePrivateVirtualInterfaceOutcome CreatePrivateVirtualInterface(
      const Model::CreatePrivateVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for CreatePrivateVirtualInterface that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreatePrivateVirtualInterfaceRequestT = Model::CreatePrivateVirtualInterfaceRequest>
  Model::CreatePrivateVirtualInterfaceOutcomeCallable CreatePrivateVirtualInterfaceCallable(
      const CreatePrivateVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreatePrivateVirtualInterface, request);
  }

  /**
   * An Async wrapper for CreatePrivateVirtualInterface that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a public virtual interface. A virtual interface is the VLAN that
   * transports Direct Connect traffic. A public virtual interface supports sending
   * traffic to public services of Amazon Web Services such as Amazon S3.</p> <p>When
   * creating an IPv6 public virtual interface (<code>addressFamily</code> is
   * <code>ipv6</code>), leave the <code>customer</code> and <code>amazon</code>
   * address fields blank to use auto-assigned IPv6 space. Custom IPv6 addresses are
   * not supported.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreatePublicVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::CreatePublicVirtualInterfaceOutcome CreatePublicVirtualInterface(
      const Model::CreatePublicVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for CreatePublicVirtualInterface that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreatePublicVirtualInterfaceRequestT = Model::CreatePublicVirtualInterfaceRequest>
  Model::CreatePublicVirtualInterfaceOutcomeCallable CreatePublicVirtualInterfaceCallable(
      const CreatePublicVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreatePublicVirtualInterface, request);
  }

  /**
   * An Async wrapper for CreatePublicVirtualInterface that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Creates a transit virtual interface. A transit virtual interface should be
   * used to access one or more transit gateways associated with Direct Connect
   * gateways. A transit virtual interface enables the connection of multiple VPCs
   * attached to a transit gateway to a Direct Connect gateway.</p>  <p>If
   * you associate your transit gateway with one or more Direct Connect gateways, the
   * Autonomous System Number (ASN) used by the transit gateway and the Direct
   * Connect gateway must be different. For example, if you use the default ASN 64512
   * for both your the transit gateway and Direct Connect gateway, the association
   * request fails.</p>  <p>A jumbo MTU value must be either 1500 or
   * 8500. No other values will be accepted. Setting the MTU of a virtual interface
   * to 8500 (jumbo frames) can cause an update to the underlying physical connection
   * if it wasn't updated to support jumbo frames. Updating the connection disrupts
   * network connectivity for all virtual interfaces associated with the connection
   * for up to 30 seconds. To check whether your connection supports jumbo frames,
   * call <a>DescribeConnections</a>. To check whether your virtual interface
   * supports jumbo frames, call <a>DescribeVirtualInterfaces</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/CreateTransitVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateTransitVirtualInterfaceOutcome CreateTransitVirtualInterface(
      const Model::CreateTransitVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for CreateTransitVirtualInterface that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreateTransitVirtualInterfaceRequestT = Model::CreateTransitVirtualInterfaceRequest>
  Model::CreateTransitVirtualInterfaceOutcomeCallable CreateTransitVirtualInterfaceCallable(
      const CreateTransitVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::CreateTransitVirtualInterface, request);
  }

  /**
   * An Async wrapper for CreateTransitVirtualInterface that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified BGP peer on the specified virtual interface with the
   * specified customer address and ASN.</p> <p>You cannot delete the last BGP peer
   * from a virtual interface.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DeleteBGPPeer">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteBGPPeerOutcome DeleteBGPPeer(const Model::DeleteBGPPeerRequest& request = {}) const;

  /**
   * A Callable wrapper for DeleteBGPPeer that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteBGPPeerRequestT = Model::DeleteBGPPeerRequest>
  Model::DeleteBGPPeerOutcomeCallable DeleteBGPPeerCallable(const DeleteBGPPeerRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DeleteBGPPeer, request);
  }

  /**
   * An Async wrapper for DeleteBGPPeer that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified connection.</p> <p>Deleting a connection only stops the
   * Direct Connect port hour and data transfer charges. If you are partnering with
   * any third parties to connect with the Direct Connect location, you must cancel
   * your service with them separately.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DeleteConnection">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const;

  /**
   * A Callable wrapper for DeleteConnection that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
  Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const DeleteConnectionRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DeleteConnection, request);
  }

  /**
   * An Async wrapper for DeleteConnection that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified Direct Connect gateway. You must first delete all
   * virtual interfaces that are attached to the Direct Connect gateway and
   * disassociate all virtual private gateways associated with the Direct Connect
   * gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DeleteDirectConnectGateway">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteDirectConnectGatewayOutcome DeleteDirectConnectGateway(
      const Model::DeleteDirectConnectGatewayRequest& request) const;

  /**
   * A Callable wrapper for DeleteDirectConnectGateway that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteDirectConnectGatewayRequestT = Model::DeleteDirectConnectGatewayRequest>
  Model::DeleteDirectConnectGatewayOutcomeCallable DeleteDirectConnectGatewayCallable(
      const DeleteDirectConnectGatewayRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DeleteDirectConnectGateway, request);
  }

  /**
   * An Async wrapper for DeleteDirectConnectGateway that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the association between the specified Direct Connect gateway and
   * virtual private gateway.</p> <p>We recommend that you specify the
   * <code>associationID</code> to delete the association. Alternatively, if you own
   * virtual gateway and a Direct Connect gateway association, you can specify the
   * <code>virtualGatewayId</code> and <code>directConnectGatewayId</code> to delete
   * an association.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DeleteDirectConnectGatewayAssociation">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteDirectConnectGatewayAssociationOutcome DeleteDirectConnectGatewayAssociation(
      const Model::DeleteDirectConnectGatewayAssociationRequest& request = {}) const;

  /**
   * A Callable wrapper for DeleteDirectConnectGatewayAssociation that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DeleteDirectConnectGatewayAssociationRequestT = Model::DeleteDirectConnectGatewayAssociationRequest>
  Model::DeleteDirectConnectGatewayAssociationOutcomeCallable DeleteDirectConnectGatewayAssociationCallable(
      const DeleteDirectConnectGatewayAssociationRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DeleteDirectConnectGatewayAssociation, request);
  }

  /**
   * An Async wrapper for DeleteDirectConnectGatewayAssociation that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the association proposal request between the specified Direct Connect
   * gateway and virtual private gateway or transit gateway.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DeleteDirectConnectGatewayAssociationProposal">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteDirectConnectGatewayAssociationProposalOutcome DeleteDirectConnectGatewayAssociationProposal(
      const Model::DeleteDirectConnectGatewayAssociationProposalRequest& request) const;

  /**
   * A Callable wrapper for DeleteDirectConnectGatewayAssociationProposal that returns a future to the operation so that it can be executed
   * in parallel to other requests.
   */
  template <typename DeleteDirectConnectGatewayAssociationProposalRequestT = Model::DeleteDirectConnectGatewayAssociationProposalRequest>
  Model::DeleteDirectConnectGatewayAssociationProposalOutcomeCallable DeleteDirectConnectGatewayAssociationProposalCallable(
      const DeleteDirectConnectGatewayAssociationProposalRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DeleteDirectConnectGatewayAssociationProposal, request);
  }

  /**
   * An Async wrapper for DeleteDirectConnectGatewayAssociationProposal that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified interconnect.</p>  <p>Intended for use by Direct
   * Connect Partners only.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DeleteInterconnect">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteInterconnectOutcome DeleteInterconnect(const Model::DeleteInterconnectRequest& request) const;

  /**
   * A Callable wrapper for DeleteInterconnect that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteInterconnectRequestT = Model::DeleteInterconnectRequest>
  Model::DeleteInterconnectOutcomeCallable DeleteInterconnectCallable(const DeleteInterconnectRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DeleteInterconnect, request);
  }

  /**
   * An Async wrapper for DeleteInterconnect that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Deletes the specified link aggregation group (LAG). You cannot delete a LAG
   * if it has active virtual interfaces or hosted connections.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DeleteLag">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteLagOutcome DeleteLag(const Model::DeleteLagRequest& request) const;

  /**
   * A Callable wrapper for DeleteLag that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DeleteLagRequestT = Model::DeleteLagRequest>
  Model::DeleteLagOutcomeCallable DeleteLagCallable(const DeleteLagRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DeleteLag, request);
  }

  /**
   * An Async wrapper for DeleteLag that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Deletes a virtual interface.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DeleteVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteVirtualInterfaceOutcome DeleteVirtualInterface(const Model::DeleteVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for DeleteVirtualInterface that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteVirtualInterfaceRequestT = Model::DeleteVirtualInterfaceRequest>
  Model::DeleteVirtualInterfaceOutcomeCallable DeleteVirtualInterfaceCallable(const DeleteVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DeleteVirtualInterface, request);
  }

  /**
   * An Async wrapper for DeleteVirtualInterface that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Displays the specified connection or all connections in this
   * Region.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeConnections">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeConnectionsOutcome DescribeConnections(const Model::DescribeConnectionsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeConnections that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeConnectionsRequestT = Model::DescribeConnectionsRequest>
  Model::DescribeConnectionsOutcomeCallable DescribeConnectionsCallable(const DescribeConnectionsRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeConnections, request);
  }

  /**
   * An Async wrapper for DescribeConnections that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Get and view a list of customer agreements, along with their signed status
   * and whether the customer is an NNIPartner, NNIPartnerV2, or a nonPartner.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeCustomerMetadata">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeCustomerMetadataOutcome DescribeCustomerMetadata(const Model::DescribeCustomerMetadataRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeCustomerMetadata that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeCustomerMetadataRequestT = Model::DescribeCustomerMetadataRequest>
  Model::DescribeCustomerMetadataOutcomeCallable DescribeCustomerMetadataCallable(
      const DescribeCustomerMetadataRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeCustomerMetadata, request);
  }

  /**
   * An Async wrapper for DescribeCustomerMetadata that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Describes one or more association proposals for connection between a virtual
   * private gateway or transit gateway and a Direct Connect gateway. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeDirectConnectGatewayAssociationProposals">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeDirectConnectGatewayAssociationProposalsOutcome DescribeDirectConnectGatewayAssociationProposals(
      const Model::DescribeDirectConnectGatewayAssociationProposalsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeDirectConnectGatewayAssociationProposals that returns a future to the operation so that it can be
   * executed in parallel to other requests.
   */
  template <
      typename DescribeDirectConnectGatewayAssociationProposalsRequestT = Model::DescribeDirectConnectGatewayAssociationProposalsRequest>
  Model::DescribeDirectConnectGatewayAssociationProposalsOutcomeCallable DescribeDirectConnectGatewayAssociationProposalsCallable(
      const DescribeDirectConnectGatewayAssociationProposalsRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeDirectConnectGatewayAssociationProposals, request);
  }

  /**
   * An Async wrapper for DescribeDirectConnectGatewayAssociationProposals that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the associations between your Direct Connect gateways and virtual
   * private gateways and transit gateways. You must specify one of the
   * following:</p> <ul> <li> <p>A Direct Connect gateway</p> <p>The response
   * contains all virtual private gateways and transit gateways associated with the
   * Direct Connect gateway.</p> </li> <li> <p>A virtual private gateway</p> <p>The
   * response contains the Direct Connect gateway.</p> </li> <li> <p>A transit
   * gateway</p> <p>The response contains the Direct Connect gateway.</p> </li> <li>
   * <p>A Direct Connect gateway and a virtual private gateway</p> <p>The response
   * contains the association between the Direct Connect gateway and virtual private
   * gateway.</p> </li> <li> <p>A Direct Connect gateway and a transit gateway</p>
   * <p>The response contains the association between the Direct Connect gateway and
   * transit gateway.</p> </li> <li> <p>A Direct Connect gateway and a virtual
   * private gateway</p> <p>The response contains the association between the Direct
   * Connect gateway and virtual private gateway.</p> </li> <li> <p>A Direct Connect
   * gateway association to a Cloud WAN core network</p> <p>The response contains the
   * Cloud WAN core network ID that the Direct Connect gateway is associated to.</p>
   * </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeDirectConnectGatewayAssociations">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeDirectConnectGatewayAssociationsOutcome DescribeDirectConnectGatewayAssociations(
      const Model::DescribeDirectConnectGatewayAssociationsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeDirectConnectGatewayAssociations that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeDirectConnectGatewayAssociationsRequestT = Model::DescribeDirectConnectGatewayAssociationsRequest>
  Model::DescribeDirectConnectGatewayAssociationsOutcomeCallable DescribeDirectConnectGatewayAssociationsCallable(
      const DescribeDirectConnectGatewayAssociationsRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeDirectConnectGatewayAssociations, request);
  }

  /**
   * An Async wrapper for DescribeDirectConnectGatewayAssociations that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the attachments between your Direct Connect gateways and virtual
   * interfaces. You must specify a Direct Connect gateway, a virtual interface, or
   * both. If you specify a Direct Connect gateway, the response contains all virtual
   * interfaces attached to the Direct Connect gateway. If you specify a virtual
   * interface, the response contains all Direct Connect gateways attached to the
   * virtual interface. If you specify both, the response contains the attachment
   * between the Direct Connect gateway and the virtual interface.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeDirectConnectGatewayAttachments">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeDirectConnectGatewayAttachmentsOutcome DescribeDirectConnectGatewayAttachments(
      const Model::DescribeDirectConnectGatewayAttachmentsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeDirectConnectGatewayAttachments that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeDirectConnectGatewayAttachmentsRequestT = Model::DescribeDirectConnectGatewayAttachmentsRequest>
  Model::DescribeDirectConnectGatewayAttachmentsOutcomeCallable DescribeDirectConnectGatewayAttachmentsCallable(
      const DescribeDirectConnectGatewayAttachmentsRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeDirectConnectGatewayAttachments, request);
  }

  /**
   * An Async wrapper for DescribeDirectConnectGatewayAttachments that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Lists all your Direct Connect gateways or only the specified Direct Connect
   * gateway. Deleted Direct Connect gateways are not returned.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeDirectConnectGateways">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeDirectConnectGatewaysOutcome DescribeDirectConnectGateways(
      const Model::DescribeDirectConnectGatewaysRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeDirectConnectGateways that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeDirectConnectGatewaysRequestT = Model::DescribeDirectConnectGatewaysRequest>
  Model::DescribeDirectConnectGatewaysOutcomeCallable DescribeDirectConnectGatewaysCallable(
      const DescribeDirectConnectGatewaysRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeDirectConnectGateways, request);
  }

  /**
   * An Async wrapper for DescribeDirectConnectGateways that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the hosted connections that have been provisioned on the specified
   * interconnect or link aggregation group (LAG).</p>  <p>Intended for use by
   * Direct Connect Partners only.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeHostedConnections">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeHostedConnectionsOutcome DescribeHostedConnections(const Model::DescribeHostedConnectionsRequest& request) const;

  /**
   * A Callable wrapper for DescribeHostedConnections that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeHostedConnectionsRequestT = Model::DescribeHostedConnectionsRequest>
  Model::DescribeHostedConnectionsOutcomeCallable DescribeHostedConnectionsCallable(
      const DescribeHostedConnectionsRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DescribeHostedConnections, request);
  }

  /**
   * An Async wrapper for DescribeHostedConnections that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the interconnects owned by the Amazon Web Services account or only the
   * specified interconnect.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeInterconnects">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeInterconnectsOutcome DescribeInterconnects(const Model::DescribeInterconnectsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeInterconnects that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeInterconnectsRequestT = Model::DescribeInterconnectsRequest>
  Model::DescribeInterconnectsOutcomeCallable DescribeInterconnectsCallable(const DescribeInterconnectsRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeInterconnects, request);
  }

  /**
   * An Async wrapper for DescribeInterconnects that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Describes all your link aggregation groups (LAG) or the specified
   * LAG.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeLags">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeLagsOutcome DescribeLags(const Model::DescribeLagsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeLags that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DescribeLagsRequestT = Model::DescribeLagsRequest>
  Model::DescribeLagsOutcomeCallable DescribeLagsCallable(const DescribeLagsRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeLags, request);
  }

  /**
   * An Async wrapper for DescribeLags that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Gets the LOA-CFA for a connection, interconnect, or link aggregation group
   * (LAG).</p> <p>The Letter of Authorization - Connecting Facility Assignment
   * (LOA-CFA) is a document that is used when establishing your cross connect to
   * Amazon Web Services at the colocation facility. For more information, see <a
   * href="https://docs.aws.amazon.com/directconnect/latest/UserGuide/Colocation.html">Requesting
   * Cross Connects at Direct Connect Locations</a> in the <i>Direct Connect User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeLoa">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeLoaOutcome DescribeLoa(const Model::DescribeLoaRequest& request) const;

  /**
   * A Callable wrapper for DescribeLoa that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DescribeLoaRequestT = Model::DescribeLoaRequest>
  Model::DescribeLoaOutcomeCallable DescribeLoaCallable(const DescribeLoaRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DescribeLoa, request);
  }

  /**
   * An Async wrapper for DescribeLoa that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Lists the Direct Connect locations in the current Amazon Web Services Region.
   * These are the locations that can be selected when calling
   * <a>CreateConnection</a> or <a>CreateInterconnect</a>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeLocations">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeLocationsOutcome DescribeLocations(const Model::DescribeLocationsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeLocations that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeLocationsRequestT = Model::DescribeLocationsRequest>
  Model::DescribeLocationsOutcomeCallable DescribeLocationsCallable(const DescribeLocationsRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeLocations, request);
  }

  /**
   * An Async wrapper for DescribeLocations that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p> Details about the router. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeRouterConfiguration">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeRouterConfigurationOutcome DescribeRouterConfiguration(
      const Model::DescribeRouterConfigurationRequest& request) const;

  /**
   * A Callable wrapper for DescribeRouterConfiguration that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeRouterConfigurationRequestT = Model::DescribeRouterConfigurationRequest>
  Model::DescribeRouterConfigurationOutcomeCallable DescribeRouterConfigurationCallable(
      const DescribeRouterConfigurationRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DescribeRouterConfiguration, request);
  }

  /**
   * An Async wrapper for DescribeRouterConfiguration that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Describes the tags associated with the specified Direct Connect
   * resources.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeTags">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const;

  /**
   * A Callable wrapper for DescribeTags that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DescribeTagsRequestT = Model::DescribeTagsRequest>
  Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DescribeTags, request);
  }

  /**
   * An Async wrapper for DescribeTags that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   *  <p>Deprecated. Use <code>DescribeVpnGateways</code> instead. See <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpnGateways.html">DescribeVPNGateways</a>
   * in the <i>Amazon Elastic Compute Cloud API Reference</i>.</p>  <p>Lists
   * the virtual private gateways owned by the Amazon Web Services account.</p>
   * <p>You can create one or more Direct Connect private virtual interfaces linked
   * to a virtual private gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeVirtualGateways">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeVirtualGatewaysOutcome DescribeVirtualGateways(const Model::DescribeVirtualGatewaysRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeVirtualGateways that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeVirtualGatewaysRequestT = Model::DescribeVirtualGatewaysRequest>
  Model::DescribeVirtualGatewaysOutcomeCallable DescribeVirtualGatewaysCallable(const DescribeVirtualGatewaysRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeVirtualGateways, request);
  }

  /**
   * An Async wrapper for DescribeVirtualGateways that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Displays all virtual interfaces for an Amazon Web Services account. Virtual
   * interfaces deleted fewer than 15 minutes before you make the request are also
   * returned. If you specify a connection ID, only the virtual interfaces associated
   * with the connection are returned. If you specify a virtual interface ID, then
   * only a single virtual interface is returned.</p> <p>A virtual interface (VLAN)
   * transmits the traffic between the Direct Connect location and the customer
   * network.</p> <ul> <li> <p>If you're using an <code>asn</code>, the response
   * includes ASN value in both the <code>asn</code> and <code>asnLong</code>
   * fields.</p> </li> <li> <p>If you're using <code>asnLong</code>, the response
   * returns a value of <code>0</code> (zero) for the <code>asn</code> attribute
   * because it exceeds the highest ASN value of 2,147,483,647 that it can
   * support</p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DescribeVirtualInterfaces">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeVirtualInterfacesOutcome DescribeVirtualInterfaces(
      const Model::DescribeVirtualInterfacesRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeVirtualInterfaces that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeVirtualInterfacesRequestT = Model::DescribeVirtualInterfacesRequest>
  Model::DescribeVirtualInterfacesOutcomeCallable DescribeVirtualInterfacesCallable(
      const DescribeVirtualInterfacesRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::DescribeVirtualInterfaces, request);
  }

  /**
   * An Async wrapper for DescribeVirtualInterfaces that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Disassociates a connection from a link aggregation group (LAG). The
   * connection is interrupted and re-established as a standalone connection (the
   * connection is not deleted; to delete the connection, use the
   * <a>DeleteConnection</a> request). If the LAG has associated virtual interfaces
   * or hosted connections, they remain associated with the LAG. A disassociated
   * connection owned by an Direct Connect Partner is automatically converted to an
   * interconnect.</p> <p>If disassociating the connection would cause the LAG to
   * fall below its setting for minimum number of operational connections, the
   * request fails, except when it's the last member of the LAG. If all connections
   * are disassociated, the LAG continues to exist as an empty LAG with no physical
   * connections. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DisassociateConnectionFromLag">AWS
   * API Reference</a></p>
   */
  virtual Model::DisassociateConnectionFromLagOutcome DisassociateConnectionFromLag(
      const Model::DisassociateConnectionFromLagRequest& request) const;

  /**
   * A Callable wrapper for DisassociateConnectionFromLag that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DisassociateConnectionFromLagRequestT = Model::DisassociateConnectionFromLagRequest>
  Model::DisassociateConnectionFromLagOutcomeCallable DisassociateConnectionFromLagCallable(
      const DisassociateConnectionFromLagRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DisassociateConnectionFromLag, request);
  }

  /**
   * An Async wrapper for DisassociateConnectionFromLag that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Removes the association between a MAC Security (MACsec) security key and a
   * Direct Connect connection.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/DisassociateMacSecKey">AWS
   * API Reference</a></p>
   */
  virtual Model::DisassociateMacSecKeyOutcome DisassociateMacSecKey(const Model::DisassociateMacSecKeyRequest& request) const;

  /**
   * A Callable wrapper for DisassociateMacSecKey that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DisassociateMacSecKeyRequestT = Model::DisassociateMacSecKeyRequest>
  Model::DisassociateMacSecKeyOutcomeCallable DisassociateMacSecKeyCallable(const DisassociateMacSecKeyRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::DisassociateMacSecKey, request);
  }

  /**
   * An Async wrapper for DisassociateMacSecKey that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Lists the virtual interface failover test history.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/ListVirtualInterfaceTestHistory">AWS
   * API Reference</a></p>
   */
  virtual Model::ListVirtualInterfaceTestHistoryOutcome ListVirtualInterfaceTestHistory(
      const Model::ListVirtualInterfaceTestHistoryRequest& request = {}) const;

  /**
   * A Callable wrapper for ListVirtualInterfaceTestHistory that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ListVirtualInterfaceTestHistoryRequestT = Model::ListVirtualInterfaceTestHistoryRequest>
  Model::ListVirtualInterfaceTestHistoryOutcomeCallable ListVirtualInterfaceTestHistoryCallable(
      const ListVirtualInterfaceTestHistoryRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::ListVirtualInterfaceTestHistory, request);
  }

  /**
   * An Async wrapper for ListVirtualInterfaceTestHistory that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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);
  }

  /**
   * <p>Starts the virtual interface failover test that verifies your configuration
   * meets your resiliency requirements by placing the BGP peering session in the
   * DOWN state. You can then send traffic to verify that there are no outages.</p>
   * <p>You can run the test on public, private, transit, and hosted virtual
   * interfaces.</p> <p>You can use <a
   * href="https://docs.aws.amazon.com/directconnect/latest/APIReference/API_ListVirtualInterfaceTestHistory.html">ListVirtualInterfaceTestHistory</a>
   * to view the virtual interface test history.</p> <p>If you need to stop the test
   * before the test interval completes, use <a
   * href="https://docs.aws.amazon.com/directconnect/latest/APIReference/API_StopBgpFailoverTest.html">StopBgpFailoverTest</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/StartBgpFailoverTest">AWS
   * API Reference</a></p>
   */
  virtual Model::StartBgpFailoverTestOutcome StartBgpFailoverTest(const Model::StartBgpFailoverTestRequest& request) const;

  /**
   * A Callable wrapper for StartBgpFailoverTest that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename StartBgpFailoverTestRequestT = Model::StartBgpFailoverTestRequest>
  Model::StartBgpFailoverTestOutcomeCallable StartBgpFailoverTestCallable(const StartBgpFailoverTestRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::StartBgpFailoverTest, request);
  }

  /**
   * An Async wrapper for StartBgpFailoverTest that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Stops the virtual interface failover test.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/StopBgpFailoverTest">AWS
   * API Reference</a></p>
   */
  virtual Model::StopBgpFailoverTestOutcome StopBgpFailoverTest(const Model::StopBgpFailoverTestRequest& request) const;

  /**
   * A Callable wrapper for StopBgpFailoverTest that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename StopBgpFailoverTestRequestT = Model::StopBgpFailoverTestRequest>
  Model::StopBgpFailoverTestOutcomeCallable StopBgpFailoverTestCallable(const StopBgpFailoverTestRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::StopBgpFailoverTest, request);
  }

  /**
   * An Async wrapper for StopBgpFailoverTest that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Adds the specified tags to the specified Direct Connect resource. Each
   * resource can have a maximum of 50 tags.</p> <p>Each tag consists of a key and an
   * optional value. If a tag with the same key is already associated with the
   * resource, this action updates its value.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/TagResource">AWS
   * API Reference</a></p>
   */
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;

  /**
   * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::TagResource, request);
  }

  /**
   * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Removes one or more tags from the specified Direct Connect
   * resource.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/UntagResource">AWS
   * API Reference</a></p>
   */
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;

  /**
   * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::UntagResource, request);
  }

  /**
   * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Updates the Direct Connect connection configuration.</p> <p>You can update
   * the following parameters for a connection:</p> <ul> <li> <p>The connection
   * name</p> </li> <li> <p>The connection's MAC Security (MACsec) encryption
   * mode.</p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/UpdateConnection">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateConnectionOutcome UpdateConnection(const Model::UpdateConnectionRequest& request) const;

  /**
   * A Callable wrapper for UpdateConnection that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
  Model::UpdateConnectionOutcomeCallable UpdateConnectionCallable(const UpdateConnectionRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::UpdateConnection, request);
  }

  /**
   * An Async wrapper for UpdateConnection that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  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);
  }

  /**
   * <p>Updates the name of a current Direct Connect gateway.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/UpdateDirectConnectGateway">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateDirectConnectGatewayOutcome UpdateDirectConnectGateway(
      const Model::UpdateDirectConnectGatewayRequest& request) const;

  /**
   * A Callable wrapper for UpdateDirectConnectGateway that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename UpdateDirectConnectGatewayRequestT = Model::UpdateDirectConnectGatewayRequest>
  Model::UpdateDirectConnectGatewayOutcomeCallable UpdateDirectConnectGatewayCallable(
      const UpdateDirectConnectGatewayRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::UpdateDirectConnectGateway, request);
  }

  /**
   * An Async wrapper for UpdateDirectConnectGateway that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  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);
  }

  /**
   * <p>Updates the specified attributes of the Direct Connect gateway
   * association.</p> <p>Add or remove prefixes from the association.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/UpdateDirectConnectGatewayAssociation">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateDirectConnectGatewayAssociationOutcome UpdateDirectConnectGatewayAssociation(
      const Model::UpdateDirectConnectGatewayAssociationRequest& request = {}) const;

  /**
   * A Callable wrapper for UpdateDirectConnectGatewayAssociation that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename UpdateDirectConnectGatewayAssociationRequestT = Model::UpdateDirectConnectGatewayAssociationRequest>
  Model::UpdateDirectConnectGatewayAssociationOutcomeCallable UpdateDirectConnectGatewayAssociationCallable(
      const UpdateDirectConnectGatewayAssociationRequestT& request = {}) const {
    return SubmitCallable(&DirectConnectClient::UpdateDirectConnectGatewayAssociation, request);
  }

  /**
   * An Async wrapper for UpdateDirectConnectGatewayAssociation that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  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);
  }

  /**
   * <p>Updates the attributes of the specified link aggregation group (LAG).</p>
   * <p>You can update the following LAG attributes:</p> <ul> <li> <p>The name of the
   * LAG.</p> </li> <li> <p>The value for the minimum number of connections that must
   * be operational for the LAG itself to be operational. </p> </li> <li> <p>The
   * LAG's MACsec encryption mode.</p> <p>Amazon Web Services assigns this value to
   * each connection which is part of the LAG.</p> </li> <li> <p>The tags</p> </li>
   * </ul>  <p>If you adjust the threshold value for the minimum number of
   * operational connections, ensure that the new value does not cause the LAG to
   * fall below the threshold and become non-operational.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/UpdateLag">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateLagOutcome UpdateLag(const Model::UpdateLagRequest& request) const;

  /**
   * A Callable wrapper for UpdateLag that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UpdateLagRequestT = Model::UpdateLagRequest>
  Model::UpdateLagOutcomeCallable UpdateLagCallable(const UpdateLagRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::UpdateLag, request);
  }

  /**
   * An Async wrapper for UpdateLag that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  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);
  }

  /**
   * <p>Updates the specified attributes of the specified virtual private
   * interface.</p> <p>Setting the MTU of a virtual interface to 8500 (jumbo frames)
   * can cause an update to the underlying physical connection if it wasn't updated
   * to support jumbo frames. Updating the connection disrupts network connectivity
   * for all virtual interfaces associated with the connection for up to 30 seconds.
   * To check whether your connection supports jumbo frames, call
   * <a>DescribeConnections</a>. To check whether your virtual interface supports
   * jumbo frames, call <a>DescribeVirtualInterfaces</a>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/directconnect-2012-10-25/UpdateVirtualInterfaceAttributes">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateVirtualInterfaceAttributesOutcome UpdateVirtualInterfaceAttributes(
      const Model::UpdateVirtualInterfaceAttributesRequest& request) const;

  /**
   * A Callable wrapper for UpdateVirtualInterfaceAttributes that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename UpdateVirtualInterfaceAttributesRequestT = Model::UpdateVirtualInterfaceAttributesRequest>
  Model::UpdateVirtualInterfaceAttributesOutcomeCallable UpdateVirtualInterfaceAttributesCallable(
      const UpdateVirtualInterfaceAttributesRequestT& request) const {
    return SubmitCallable(&DirectConnectClient::UpdateVirtualInterfaceAttributes, request);
  }

  /**
   * An Async wrapper for UpdateVirtualInterfaceAttributes that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  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
