/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include <aws/directconnect/DirectConnect_EXPORTS.h> #include <aws/core/client/ClientConfiguration.h> #include <aws/core/client/AWSClient.h> #include <aws/core/client/AWSClientAsyncCRTP.h> #include <aws/core/utils/json/JsonSerializer.h> #include <aws/directconnect/DirectConnectServiceClientModel.h> namespace Aws { namespace DirectConnect { /** * <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* SERVICE_NAME; static const char* ALLOCATION_TAG; 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 = Aws::MakeShared<DirectConnectEndpointProvider>(ALLOCATION_TAG)); /** * 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 = Aws::MakeShared<DirectConnectEndpointProvider>(ALLOCATION_TAG), 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 = Aws::MakeShared<DirectConnectEndpointProvider>(ALLOCATION_TAG), 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 an Direct Connect dedicated 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 ConfirmCustomerAgreementRequestT& request, const ConfirmCustomerAgreementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 CreateBGPPeerRequestT& request, const CreateBGPPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 or 10Gbps) and must terminate at the same * Direct Connect endpoint.</p> <p>You can have up to 10 dedicated connections per * LAG. 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 9001 (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 DeleteBGPPeerRequestT& request, const DeleteBGPPeerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 DeleteDirectConnectGatewayAssociationRequestT& request, const DeleteDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 DescribeConnectionsRequestT& request, const DescribeConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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; /** * 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 = void> Model::DescribeCustomerMetadataOutcomeCallable DescribeCustomerMetadataCallable() const { return SubmitCallable(&DirectConnectClient::DescribeCustomerMetadata); } /** * An Async wrapper for DescribeCustomerMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename = void> void DescribeCustomerMetadataAsync(const DescribeCustomerMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&DirectConnectClient::DescribeCustomerMetadata, 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 DescribeDirectConnectGatewayAssociationProposalsRequestT& request, const DescribeDirectConnectGatewayAssociationProposalsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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> </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 DescribeDirectConnectGatewayAssociationsRequestT& request, const DescribeDirectConnectGatewayAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 DescribeDirectConnectGatewayAttachmentsRequestT& request, const DescribeDirectConnectGatewayAttachmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 DescribeDirectConnectGatewaysRequestT& request, const DescribeDirectConnectGatewaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 DescribeInterconnectsRequestT& request, const DescribeInterconnectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 DescribeLagsRequestT& request, const DescribeLagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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; /** * 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 = void> Model::DescribeLocationsOutcomeCallable DescribeLocationsCallable() const { return SubmitCallable(&DirectConnectClient::DescribeLocations); } /** * An Async wrapper for DescribeLocations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename = void> void DescribeLocationsAsync(const DescribeLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&DirectConnectClient::DescribeLocations, 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>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; /** * 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 = void> Model::DescribeVirtualGatewaysOutcomeCallable DescribeVirtualGatewaysCallable() const { return SubmitCallable(&DirectConnectClient::DescribeVirtualGateways); } /** * An Async wrapper for DescribeVirtualGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template<typename = void> void DescribeVirtualGatewaysAsync(const DescribeVirtualGatewaysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const { return SubmitAsync(&DirectConnectClient::DescribeVirtualGateways, 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><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 DescribeVirtualInterfacesRequestT& request, const DescribeVirtualInterfacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 an * Direct Connect dedicated 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 ListVirtualInterfaceTestHistoryRequestT& request, const ListVirtualInterfaceTestHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 dedicated 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 UpdateDirectConnectGatewayAssociationRequestT& request, const UpdateDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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 9001 (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<Aws::Utils::Threading::Executor> m_executor; std::shared_ptr<DirectConnectEndpointProviderBase> m_endpointProvider; }; } // namespace DirectConnect } // namespace Aws