/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace Aws { namespace Http { class HttpClient; class HttpClientFactory; } // namespace Http namespace Utils { template< typename R, typename E> class Outcome; namespace Threading { class Executor; } // namespace Threading } // namespace Utils namespace Auth { class AWSCredentials; class AWSCredentialsProvider; } // namespace Auth namespace Client { class RetryStrategy; } // namespace Client namespace DirectConnect { namespace Model { class AcceptDirectConnectGatewayAssociationProposalRequest; class AllocateHostedConnectionRequest; class AllocatePrivateVirtualInterfaceRequest; class AllocatePublicVirtualInterfaceRequest; class AllocateTransitVirtualInterfaceRequest; class AssociateConnectionWithLagRequest; class AssociateHostedConnectionRequest; class AssociateVirtualInterfaceRequest; class ConfirmConnectionRequest; class ConfirmPrivateVirtualInterfaceRequest; class ConfirmPublicVirtualInterfaceRequest; class ConfirmTransitVirtualInterfaceRequest; class CreateBGPPeerRequest; class CreateConnectionRequest; class CreateDirectConnectGatewayRequest; class CreateDirectConnectGatewayAssociationRequest; class CreateDirectConnectGatewayAssociationProposalRequest; class CreateInterconnectRequest; class CreateLagRequest; class CreatePrivateVirtualInterfaceRequest; class CreatePublicVirtualInterfaceRequest; class CreateTransitVirtualInterfaceRequest; class DeleteBGPPeerRequest; class DeleteConnectionRequest; class DeleteDirectConnectGatewayRequest; class DeleteDirectConnectGatewayAssociationRequest; class DeleteDirectConnectGatewayAssociationProposalRequest; class DeleteInterconnectRequest; class DeleteLagRequest; class DeleteVirtualInterfaceRequest; class DescribeConnectionsRequest; class DescribeDirectConnectGatewayAssociationProposalsRequest; class DescribeDirectConnectGatewayAssociationsRequest; class DescribeDirectConnectGatewayAttachmentsRequest; class DescribeDirectConnectGatewaysRequest; class DescribeHostedConnectionsRequest; class DescribeInterconnectsRequest; class DescribeLagsRequest; class DescribeLoaRequest; class DescribeTagsRequest; class DescribeVirtualInterfacesRequest; class DisassociateConnectionFromLagRequest; class ListVirtualInterfaceTestHistoryRequest; class StartBgpFailoverTestRequest; class StopBgpFailoverTestRequest; class TagResourceRequest; class UntagResourceRequest; class UpdateDirectConnectGatewayAssociationRequest; class UpdateLagRequest; class UpdateVirtualInterfaceAttributesRequest; typedef Aws::Utils::Outcome AcceptDirectConnectGatewayAssociationProposalOutcome; typedef Aws::Utils::Outcome AllocateHostedConnectionOutcome; typedef Aws::Utils::Outcome AllocatePrivateVirtualInterfaceOutcome; typedef Aws::Utils::Outcome AllocatePublicVirtualInterfaceOutcome; typedef Aws::Utils::Outcome AllocateTransitVirtualInterfaceOutcome; typedef Aws::Utils::Outcome AssociateConnectionWithLagOutcome; typedef Aws::Utils::Outcome AssociateHostedConnectionOutcome; typedef Aws::Utils::Outcome AssociateVirtualInterfaceOutcome; typedef Aws::Utils::Outcome ConfirmConnectionOutcome; typedef Aws::Utils::Outcome ConfirmPrivateVirtualInterfaceOutcome; typedef Aws::Utils::Outcome ConfirmPublicVirtualInterfaceOutcome; typedef Aws::Utils::Outcome ConfirmTransitVirtualInterfaceOutcome; typedef Aws::Utils::Outcome CreateBGPPeerOutcome; typedef Aws::Utils::Outcome CreateConnectionOutcome; typedef Aws::Utils::Outcome CreateDirectConnectGatewayOutcome; typedef Aws::Utils::Outcome CreateDirectConnectGatewayAssociationOutcome; typedef Aws::Utils::Outcome CreateDirectConnectGatewayAssociationProposalOutcome; typedef Aws::Utils::Outcome CreateInterconnectOutcome; typedef Aws::Utils::Outcome CreateLagOutcome; typedef Aws::Utils::Outcome CreatePrivateVirtualInterfaceOutcome; typedef Aws::Utils::Outcome CreatePublicVirtualInterfaceOutcome; typedef Aws::Utils::Outcome CreateTransitVirtualInterfaceOutcome; typedef Aws::Utils::Outcome DeleteBGPPeerOutcome; typedef Aws::Utils::Outcome DeleteConnectionOutcome; typedef Aws::Utils::Outcome DeleteDirectConnectGatewayOutcome; typedef Aws::Utils::Outcome DeleteDirectConnectGatewayAssociationOutcome; typedef Aws::Utils::Outcome DeleteDirectConnectGatewayAssociationProposalOutcome; typedef Aws::Utils::Outcome DeleteInterconnectOutcome; typedef Aws::Utils::Outcome DeleteLagOutcome; typedef Aws::Utils::Outcome DeleteVirtualInterfaceOutcome; typedef Aws::Utils::Outcome DescribeConnectionsOutcome; typedef Aws::Utils::Outcome DescribeDirectConnectGatewayAssociationProposalsOutcome; typedef Aws::Utils::Outcome DescribeDirectConnectGatewayAssociationsOutcome; typedef Aws::Utils::Outcome DescribeDirectConnectGatewayAttachmentsOutcome; typedef Aws::Utils::Outcome DescribeDirectConnectGatewaysOutcome; typedef Aws::Utils::Outcome DescribeHostedConnectionsOutcome; typedef Aws::Utils::Outcome DescribeInterconnectsOutcome; typedef Aws::Utils::Outcome DescribeLagsOutcome; typedef Aws::Utils::Outcome DescribeLoaOutcome; typedef Aws::Utils::Outcome DescribeLocationsOutcome; typedef Aws::Utils::Outcome DescribeTagsOutcome; typedef Aws::Utils::Outcome DescribeVirtualGatewaysOutcome; typedef Aws::Utils::Outcome DescribeVirtualInterfacesOutcome; typedef Aws::Utils::Outcome DisassociateConnectionFromLagOutcome; typedef Aws::Utils::Outcome ListVirtualInterfaceTestHistoryOutcome; typedef Aws::Utils::Outcome StartBgpFailoverTestOutcome; typedef Aws::Utils::Outcome StopBgpFailoverTestOutcome; typedef Aws::Utils::Outcome TagResourceOutcome; typedef Aws::Utils::Outcome UntagResourceOutcome; typedef Aws::Utils::Outcome UpdateDirectConnectGatewayAssociationOutcome; typedef Aws::Utils::Outcome UpdateLagOutcome; typedef Aws::Utils::Outcome UpdateVirtualInterfaceAttributesOutcome; typedef std::future AcceptDirectConnectGatewayAssociationProposalOutcomeCallable; typedef std::future AllocateHostedConnectionOutcomeCallable; typedef std::future AllocatePrivateVirtualInterfaceOutcomeCallable; typedef std::future AllocatePublicVirtualInterfaceOutcomeCallable; typedef std::future AllocateTransitVirtualInterfaceOutcomeCallable; typedef std::future AssociateConnectionWithLagOutcomeCallable; typedef std::future AssociateHostedConnectionOutcomeCallable; typedef std::future AssociateVirtualInterfaceOutcomeCallable; typedef std::future ConfirmConnectionOutcomeCallable; typedef std::future ConfirmPrivateVirtualInterfaceOutcomeCallable; typedef std::future ConfirmPublicVirtualInterfaceOutcomeCallable; typedef std::future ConfirmTransitVirtualInterfaceOutcomeCallable; typedef std::future CreateBGPPeerOutcomeCallable; typedef std::future CreateConnectionOutcomeCallable; typedef std::future CreateDirectConnectGatewayOutcomeCallable; typedef std::future CreateDirectConnectGatewayAssociationOutcomeCallable; typedef std::future CreateDirectConnectGatewayAssociationProposalOutcomeCallable; typedef std::future CreateInterconnectOutcomeCallable; typedef std::future CreateLagOutcomeCallable; typedef std::future CreatePrivateVirtualInterfaceOutcomeCallable; typedef std::future CreatePublicVirtualInterfaceOutcomeCallable; typedef std::future CreateTransitVirtualInterfaceOutcomeCallable; typedef std::future DeleteBGPPeerOutcomeCallable; typedef std::future DeleteConnectionOutcomeCallable; typedef std::future DeleteDirectConnectGatewayOutcomeCallable; typedef std::future DeleteDirectConnectGatewayAssociationOutcomeCallable; typedef std::future DeleteDirectConnectGatewayAssociationProposalOutcomeCallable; typedef std::future DeleteInterconnectOutcomeCallable; typedef std::future DeleteLagOutcomeCallable; typedef std::future DeleteVirtualInterfaceOutcomeCallable; typedef std::future DescribeConnectionsOutcomeCallable; typedef std::future DescribeDirectConnectGatewayAssociationProposalsOutcomeCallable; typedef std::future DescribeDirectConnectGatewayAssociationsOutcomeCallable; typedef std::future DescribeDirectConnectGatewayAttachmentsOutcomeCallable; typedef std::future DescribeDirectConnectGatewaysOutcomeCallable; typedef std::future DescribeHostedConnectionsOutcomeCallable; typedef std::future DescribeInterconnectsOutcomeCallable; typedef std::future DescribeLagsOutcomeCallable; typedef std::future DescribeLoaOutcomeCallable; typedef std::future DescribeLocationsOutcomeCallable; typedef std::future DescribeTagsOutcomeCallable; typedef std::future DescribeVirtualGatewaysOutcomeCallable; typedef std::future DescribeVirtualInterfacesOutcomeCallable; typedef std::future DisassociateConnectionFromLagOutcomeCallable; typedef std::future ListVirtualInterfaceTestHistoryOutcomeCallable; typedef std::future StartBgpFailoverTestOutcomeCallable; typedef std::future StopBgpFailoverTestOutcomeCallable; typedef std::future TagResourceOutcomeCallable; typedef std::future UntagResourceOutcomeCallable; typedef std::future UpdateDirectConnectGatewayAssociationOutcomeCallable; typedef std::future UpdateLagOutcomeCallable; typedef std::future UpdateVirtualInterfaceAttributesOutcomeCallable; } // namespace Model class DirectConnectClient; typedef std::function&) > AcceptDirectConnectGatewayAssociationProposalResponseReceivedHandler; typedef std::function&) > AllocateHostedConnectionResponseReceivedHandler; typedef std::function&) > AllocatePrivateVirtualInterfaceResponseReceivedHandler; typedef std::function&) > AllocatePublicVirtualInterfaceResponseReceivedHandler; typedef std::function&) > AllocateTransitVirtualInterfaceResponseReceivedHandler; typedef std::function&) > AssociateConnectionWithLagResponseReceivedHandler; typedef std::function&) > AssociateHostedConnectionResponseReceivedHandler; typedef std::function&) > AssociateVirtualInterfaceResponseReceivedHandler; typedef std::function&) > ConfirmConnectionResponseReceivedHandler; typedef std::function&) > ConfirmPrivateVirtualInterfaceResponseReceivedHandler; typedef std::function&) > ConfirmPublicVirtualInterfaceResponseReceivedHandler; typedef std::function&) > ConfirmTransitVirtualInterfaceResponseReceivedHandler; typedef std::function&) > CreateBGPPeerResponseReceivedHandler; typedef std::function&) > CreateConnectionResponseReceivedHandler; typedef std::function&) > CreateDirectConnectGatewayResponseReceivedHandler; typedef std::function&) > CreateDirectConnectGatewayAssociationResponseReceivedHandler; typedef std::function&) > CreateDirectConnectGatewayAssociationProposalResponseReceivedHandler; typedef std::function&) > CreateInterconnectResponseReceivedHandler; typedef std::function&) > CreateLagResponseReceivedHandler; typedef std::function&) > CreatePrivateVirtualInterfaceResponseReceivedHandler; typedef std::function&) > CreatePublicVirtualInterfaceResponseReceivedHandler; typedef std::function&) > CreateTransitVirtualInterfaceResponseReceivedHandler; typedef std::function&) > DeleteBGPPeerResponseReceivedHandler; typedef std::function&) > DeleteConnectionResponseReceivedHandler; typedef std::function&) > DeleteDirectConnectGatewayResponseReceivedHandler; typedef std::function&) > DeleteDirectConnectGatewayAssociationResponseReceivedHandler; typedef std::function&) > DeleteDirectConnectGatewayAssociationProposalResponseReceivedHandler; typedef std::function&) > DeleteInterconnectResponseReceivedHandler; typedef std::function&) > DeleteLagResponseReceivedHandler; typedef std::function&) > DeleteVirtualInterfaceResponseReceivedHandler; typedef std::function&) > DescribeConnectionsResponseReceivedHandler; typedef std::function&) > DescribeDirectConnectGatewayAssociationProposalsResponseReceivedHandler; typedef std::function&) > DescribeDirectConnectGatewayAssociationsResponseReceivedHandler; typedef std::function&) > DescribeDirectConnectGatewayAttachmentsResponseReceivedHandler; typedef std::function&) > DescribeDirectConnectGatewaysResponseReceivedHandler; typedef std::function&) > DescribeHostedConnectionsResponseReceivedHandler; typedef std::function&) > DescribeInterconnectsResponseReceivedHandler; typedef std::function&) > DescribeLagsResponseReceivedHandler; typedef std::function&) > DescribeLoaResponseReceivedHandler; typedef std::function&) > DescribeLocationsResponseReceivedHandler; typedef std::function&) > DescribeTagsResponseReceivedHandler; typedef std::function&) > DescribeVirtualGatewaysResponseReceivedHandler; typedef std::function&) > DescribeVirtualInterfacesResponseReceivedHandler; typedef std::function&) > DisassociateConnectionFromLagResponseReceivedHandler; typedef std::function&) > ListVirtualInterfaceTestHistoryResponseReceivedHandler; typedef std::function&) > StartBgpFailoverTestResponseReceivedHandler; typedef std::function&) > StopBgpFailoverTestResponseReceivedHandler; typedef std::function&) > TagResourceResponseReceivedHandler; typedef std::function&) > UntagResourceResponseReceivedHandler; typedef std::function&) > UpdateDirectConnectGatewayAssociationResponseReceivedHandler; typedef std::function&) > UpdateLagResponseReceivedHandler; typedef std::function&) > UpdateVirtualInterfaceAttributesResponseReceivedHandler; /** *

AWS Direct Connect links your internal network to an AWS Direct Connect * location over a standard Ethernet fiber-optic cable. One end of the cable is * connected to your router, the other to an AWS Direct Connect router. With this * connection in place, you can create virtual interfaces directly to the AWS 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 AWS * Regions except the China (Beijing) and (China) Ningxia Regions. AWS resources in * the China Regions can only be accessed through locations associated with those * Regions.

*/ class AWS_DIRECTCONNECT_API DirectConnectClient : public Aws::Client::AWSJsonClient { public: typedef Aws::Client::AWSJsonClient BASECLASS; /** * 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 = Aws::Client::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 = Aws::Client::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& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); virtual ~DirectConnectClient(); /** *

Accepts a proposal request to attach a virtual private gateway or transit * gateway to a Direct Connect gateway.

See Also:

AWS * API Reference

*/ virtual Model::AcceptDirectConnectGatewayAssociationProposalOutcome AcceptDirectConnectGatewayAssociationProposal(const Model::AcceptDirectConnectGatewayAssociationProposalRequest& request) const; /** *

Accepts a proposal request to attach a virtual private gateway or transit * gateway to a Direct Connect gateway.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::AcceptDirectConnectGatewayAssociationProposalOutcomeCallable AcceptDirectConnectGatewayAssociationProposalCallable(const Model::AcceptDirectConnectGatewayAssociationProposalRequest& request) const; /** *

Accepts a proposal request to attach a virtual private gateway or transit * gateway to a Direct Connect gateway.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void AcceptDirectConnectGatewayAssociationProposalAsync(const Model::AcceptDirectConnectGatewayAssociationProposalRequest& request, const AcceptDirectConnectGatewayAssociationProposalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Creates a hosted connection on the specified interconnect or a link * aggregation group (LAG) of interconnects.

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. AWS polices the hosted * connection for the specified capacity and the AWS Direct Connect Partner must * also police the hosted connection for the specified capacity.

*

Intended for use by AWS Direct Connect Partners only.

See * Also:

AWS * API Reference

*/ virtual Model::AllocateHostedConnectionOutcome AllocateHostedConnection(const Model::AllocateHostedConnectionRequest& request) const; /** *

Creates a hosted connection on the specified interconnect or a link * aggregation group (LAG) of interconnects.

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. AWS polices the hosted * connection for the specified capacity and the AWS Direct Connect Partner must * also police the hosted connection for the specified capacity.

*

Intended for use by AWS Direct Connect Partners only.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::AllocateHostedConnectionOutcomeCallable AllocateHostedConnectionCallable(const Model::AllocateHostedConnectionRequest& request) const; /** *

Creates a hosted connection on the specified interconnect or a link * aggregation group (LAG) of interconnects.

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. AWS polices the hosted * connection for the specified capacity and the AWS Direct Connect Partner must * also police the hosted connection for the specified capacity.

*

Intended for use by AWS Direct Connect Partners only.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void AllocateHostedConnectionAsync(const Model::AllocateHostedConnectionRequest& request, const AllocateHostedConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Provisions a private virtual interface to be owned by the specified AWS * account.

Virtual interfaces created using this action must be confirmed * by the owner using ConfirmPrivateVirtualInterface. Until then, the * virtual interface is in the Confirming state and is not available * to handle traffic.

See Also:

AWS * API Reference

*/ virtual Model::AllocatePrivateVirtualInterfaceOutcome AllocatePrivateVirtualInterface(const Model::AllocatePrivateVirtualInterfaceRequest& request) const; /** *

Provisions a private virtual interface to be owned by the specified AWS * account.

Virtual interfaces created using this action must be confirmed * by the owner using ConfirmPrivateVirtualInterface. Until then, the * virtual interface is in the Confirming state and is not available * to handle traffic.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::AllocatePrivateVirtualInterfaceOutcomeCallable AllocatePrivateVirtualInterfaceCallable(const Model::AllocatePrivateVirtualInterfaceRequest& request) const; /** *

Provisions a private virtual interface to be owned by the specified AWS * account.

Virtual interfaces created using this action must be confirmed * by the owner using ConfirmPrivateVirtualInterface. Until then, the * virtual interface is in the Confirming state and is not available * to handle traffic.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void AllocatePrivateVirtualInterfaceAsync(const Model::AllocatePrivateVirtualInterfaceRequest& request, const AllocatePrivateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Provisions a public virtual interface to be owned by the specified AWS * account.

The owner of a connection calls this function to provision a * public virtual interface to be owned by the specified AWS account.

*

Virtual interfaces created using this function must be confirmed by the owner * using ConfirmPublicVirtualInterface. Until this step has been completed, * the virtual interface is in the confirming state and is not * available to handle traffic.

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.

See Also:

AWS * API Reference

*/ virtual Model::AllocatePublicVirtualInterfaceOutcome AllocatePublicVirtualInterface(const Model::AllocatePublicVirtualInterfaceRequest& request) const; /** *

Provisions a public virtual interface to be owned by the specified AWS * account.

The owner of a connection calls this function to provision a * public virtual interface to be owned by the specified AWS account.

*

Virtual interfaces created using this function must be confirmed by the owner * using ConfirmPublicVirtualInterface. Until this step has been completed, * the virtual interface is in the confirming state and is not * available to handle traffic.

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::AllocatePublicVirtualInterfaceOutcomeCallable AllocatePublicVirtualInterfaceCallable(const Model::AllocatePublicVirtualInterfaceRequest& request) const; /** *

Provisions a public virtual interface to be owned by the specified AWS * account.

The owner of a connection calls this function to provision a * public virtual interface to be owned by the specified AWS account.

*

Virtual interfaces created using this function must be confirmed by the owner * using ConfirmPublicVirtualInterface. Until this step has been completed, * the virtual interface is in the confirming state and is not * available to handle traffic.

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void AllocatePublicVirtualInterfaceAsync(const Model::AllocatePublicVirtualInterfaceRequest& request, const AllocatePublicVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Provisions a transit virtual interface to be owned by the specified AWS * account. Use this type of interface to connect a transit gateway to your Direct * Connect gateway.

The owner of a connection provisions a transit virtual * interface to be owned by the specified AWS account.

After you create a * transit virtual interface, it must be confirmed by the owner using * ConfirmTransitVirtualInterface. Until this step has been completed, the * transit virtual interface is in the requested state and is not * available to handle traffic.

See Also:

AWS * API Reference

*/ virtual Model::AllocateTransitVirtualInterfaceOutcome AllocateTransitVirtualInterface(const Model::AllocateTransitVirtualInterfaceRequest& request) const; /** *

Provisions a transit virtual interface to be owned by the specified AWS * account. Use this type of interface to connect a transit gateway to your Direct * Connect gateway.

The owner of a connection provisions a transit virtual * interface to be owned by the specified AWS account.

After you create a * transit virtual interface, it must be confirmed by the owner using * ConfirmTransitVirtualInterface. Until this step has been completed, the * transit virtual interface is in the requested state and is not * available to handle traffic.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::AllocateTransitVirtualInterfaceOutcomeCallable AllocateTransitVirtualInterfaceCallable(const Model::AllocateTransitVirtualInterfaceRequest& request) const; /** *

Provisions a transit virtual interface to be owned by the specified AWS * account. Use this type of interface to connect a transit gateway to your Direct * Connect gateway.

The owner of a connection provisions a transit virtual * interface to be owned by the specified AWS account.

After you create a * transit virtual interface, it must be confirmed by the owner using * ConfirmTransitVirtualInterface. Until this step has been completed, the * transit virtual interface is in the requested state and is not * available to handle traffic.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void AllocateTransitVirtualInterfaceAsync(const Model::AllocateTransitVirtualInterfaceRequest& request, const AllocateTransitVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 AWS is interrupted). The connection must be hosted on the same * AWS 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.

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.

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.

See Also:

* AWS * API Reference

*/ virtual Model::AssociateConnectionWithLagOutcome AssociateConnectionWithLag(const Model::AssociateConnectionWithLagRequest& request) const; /** *

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 AWS is interrupted). The connection must be hosted on the same * AWS 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.

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.

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.

See Also:

* AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::AssociateConnectionWithLagOutcomeCallable AssociateConnectionWithLagCallable(const Model::AssociateConnectionWithLagRequest& request) const; /** *

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 AWS is interrupted). The connection must be hosted on the same * AWS 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.

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.

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.

See Also:

* AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void AssociateConnectionWithLagAsync(const Model::AssociateConnectionWithLagRequest& request, const AssociateConnectionWithLagResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 AWS as it is being migrated.

Intended for use by * AWS Direct Connect Partners only.

See Also:

AWS * API Reference

*/ virtual Model::AssociateHostedConnectionOutcome AssociateHostedConnection(const Model::AssociateHostedConnectionRequest& request) const; /** *

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 AWS as it is being migrated.

Intended for use by * AWS Direct Connect Partners only.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::AssociateHostedConnectionOutcomeCallable AssociateHostedConnectionCallable(const Model::AssociateHostedConnectionRequest& request) const; /** *

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 AWS as it is being migrated.

Intended for use by * AWS Direct Connect Partners only.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void AssociateHostedConnectionAsync(const Model::AssociateHostedConnectionRequest& request, const AssociateHostedConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Associates a virtual interface with a specified link aggregation group (LAG) * or connection. Connectivity to AWS 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.

Virtual interfaces associated with a hosted * connection cannot be associated with a LAG; hosted connections must be migrated * along with their virtual interfaces using AssociateHostedConnection.

*

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.

See Also:

AWS * API Reference

*/ virtual Model::AssociateVirtualInterfaceOutcome AssociateVirtualInterface(const Model::AssociateVirtualInterfaceRequest& request) const; /** *

Associates a virtual interface with a specified link aggregation group (LAG) * or connection. Connectivity to AWS 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.

Virtual interfaces associated with a hosted * connection cannot be associated with a LAG; hosted connections must be migrated * along with their virtual interfaces using AssociateHostedConnection.

*

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::AssociateVirtualInterfaceOutcomeCallable AssociateVirtualInterfaceCallable(const Model::AssociateVirtualInterfaceRequest& request) const; /** *

Associates a virtual interface with a specified link aggregation group (LAG) * or connection. Connectivity to AWS 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.

Virtual interfaces associated with a hosted * connection cannot be associated with a LAG; hosted connections must be migrated * along with their virtual interfaces using AssociateHostedConnection.

*

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void AssociateVirtualInterfaceAsync(const Model::AssociateVirtualInterfaceRequest& request, const AssociateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Confirms the creation of the specified hosted connection on an * interconnect.

Upon creation, the hosted connection is initially in the * Ordering state, and remains in this state until the owner confirms * creation of the hosted connection.

See Also:

AWS * API Reference

*/ virtual Model::ConfirmConnectionOutcome ConfirmConnection(const Model::ConfirmConnectionRequest& request) const; /** *

Confirms the creation of the specified hosted connection on an * interconnect.

Upon creation, the hosted connection is initially in the * Ordering state, and remains in this state until the owner confirms * creation of the hosted connection.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ConfirmConnectionOutcomeCallable ConfirmConnectionCallable(const Model::ConfirmConnectionRequest& request) const; /** *

Confirms the creation of the specified hosted connection on an * interconnect.

Upon creation, the hosted connection is initially in the * Ordering state, and remains in this state until the owner confirms * creation of the hosted connection.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ConfirmConnectionAsync(const Model::ConfirmConnectionRequest& request, const ConfirmConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Accepts ownership of a private virtual interface created by another AWS * account.

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.

See * Also:

AWS * API Reference

*/ virtual Model::ConfirmPrivateVirtualInterfaceOutcome ConfirmPrivateVirtualInterface(const Model::ConfirmPrivateVirtualInterfaceRequest& request) const; /** *

Accepts ownership of a private virtual interface created by another AWS * account.

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.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ConfirmPrivateVirtualInterfaceOutcomeCallable ConfirmPrivateVirtualInterfaceCallable(const Model::ConfirmPrivateVirtualInterfaceRequest& request) const; /** *

Accepts ownership of a private virtual interface created by another AWS * account.

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.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ConfirmPrivateVirtualInterfaceAsync(const Model::ConfirmPrivateVirtualInterfaceRequest& request, const ConfirmPrivateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Accepts ownership of a public virtual interface created by another AWS * account.

After the virtual interface owner makes this call, the specified * virtual interface is created and made available to handle traffic.

See * Also:

AWS * API Reference

*/ virtual Model::ConfirmPublicVirtualInterfaceOutcome ConfirmPublicVirtualInterface(const Model::ConfirmPublicVirtualInterfaceRequest& request) const; /** *

Accepts ownership of a public virtual interface created by another AWS * account.

After the virtual interface owner makes this call, the specified * virtual interface is created and made available to handle traffic.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ConfirmPublicVirtualInterfaceOutcomeCallable ConfirmPublicVirtualInterfaceCallable(const Model::ConfirmPublicVirtualInterfaceRequest& request) const; /** *

Accepts ownership of a public virtual interface created by another AWS * account.

After the virtual interface owner makes this call, the specified * virtual interface is created and made available to handle traffic.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ConfirmPublicVirtualInterfaceAsync(const Model::ConfirmPublicVirtualInterfaceRequest& request, const ConfirmPublicVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Accepts ownership of a transit virtual interface created by another AWS * account.

After the owner of the transit virtual interface makes this * call, the specified transit virtual interface is created and made available to * handle traffic.

See Also:

AWS * API Reference

*/ virtual Model::ConfirmTransitVirtualInterfaceOutcome ConfirmTransitVirtualInterface(const Model::ConfirmTransitVirtualInterfaceRequest& request) const; /** *

Accepts ownership of a transit virtual interface created by another AWS * account.

After the owner of the transit virtual interface makes this * call, the specified transit virtual interface is created and made available to * handle traffic.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ConfirmTransitVirtualInterfaceOutcomeCallable ConfirmTransitVirtualInterfaceCallable(const Model::ConfirmTransitVirtualInterfaceRequest& request) const; /** *

Accepts ownership of a transit virtual interface created by another AWS * account.

After the owner of the transit virtual interface makes this * call, the specified transit virtual interface is created and made available to * handle traffic.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ConfirmTransitVirtualInterfaceAsync(const Model::ConfirmTransitVirtualInterfaceRequest& request, const ConfirmTransitVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Creates a BGP peer on the specified virtual interface.

You must create * a BGP peer for the corresponding address family (IPv4/IPv6) in order to access * AWS resources that also use that address family.

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.

*

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.

For a public virtual * interface, the Autonomous System Number (ASN) must be private or already * whitelisted for the virtual interface.

See Also:

AWS * API Reference

*/ virtual Model::CreateBGPPeerOutcome CreateBGPPeer(const Model::CreateBGPPeerRequest& request) const; /** *

Creates a BGP peer on the specified virtual interface.

You must create * a BGP peer for the corresponding address family (IPv4/IPv6) in order to access * AWS resources that also use that address family.

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.

*

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.

For a public virtual * interface, the Autonomous System Number (ASN) must be private or already * whitelisted for the virtual interface.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateBGPPeerOutcomeCallable CreateBGPPeerCallable(const Model::CreateBGPPeerRequest& request) const; /** *

Creates a BGP peer on the specified virtual interface.

You must create * a BGP peer for the corresponding address family (IPv4/IPv6) in order to access * AWS resources that also use that address family.

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.

*

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.

For a public virtual * interface, the Autonomous System Number (ASN) must be private or already * whitelisted for the virtual interface.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateBGPPeerAsync(const Model::CreateBGPPeerRequest& request, const CreateBGPPeerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Creates a connection between a customer network and a specific AWS Direct * Connect location.

A connection links your internal network to an AWS * Direct Connect location over a standard Ethernet fiber-optic cable. One end of * the cable is connected to your router, the other to an AWS Direct Connect * router.

To find the locations for your Region, use * DescribeLocations.

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 AWS 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.

See * Also:

AWS * API Reference

*/ virtual Model::CreateConnectionOutcome CreateConnection(const Model::CreateConnectionRequest& request) const; /** *

Creates a connection between a customer network and a specific AWS Direct * Connect location.

A connection links your internal network to an AWS * Direct Connect location over a standard Ethernet fiber-optic cable. One end of * the cable is connected to your router, the other to an AWS Direct Connect * router.

To find the locations for your Region, use * DescribeLocations.

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 AWS 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.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateConnectionOutcomeCallable CreateConnectionCallable(const Model::CreateConnectionRequest& request) const; /** *

Creates a connection between a customer network and a specific AWS Direct * Connect location.

A connection links your internal network to an AWS * Direct Connect location over a standard Ethernet fiber-optic cable. One end of * the cable is connected to your router, the other to an AWS Direct Connect * router.

To find the locations for your Region, use * DescribeLocations.

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 AWS 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.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateConnectionAsync(const Model::CreateConnectionRequest& request, const CreateConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 AWS Region after it is * created. The virtual interfaces and virtual private gateways that are connected * through a Direct Connect gateway can be in different AWS 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.

See * Also:

AWS * API Reference

*/ virtual Model::CreateDirectConnectGatewayOutcome CreateDirectConnectGateway(const Model::CreateDirectConnectGatewayRequest& request) const; /** *

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 AWS Region after it is * created. The virtual interfaces and virtual private gateways that are connected * through a Direct Connect gateway can be in different AWS 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.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateDirectConnectGatewayOutcomeCallable CreateDirectConnectGatewayCallable(const Model::CreateDirectConnectGatewayRequest& request) const; /** *

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 AWS Region after it is * created. The virtual interfaces and virtual private gateways that are connected * through a Direct Connect gateway can be in different AWS 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.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateDirectConnectGatewayAsync(const Model::CreateDirectConnectGatewayRequest& request, const CreateDirectConnectGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::CreateDirectConnectGatewayAssociationOutcome CreateDirectConnectGatewayAssociation(const Model::CreateDirectConnectGatewayAssociationRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateDirectConnectGatewayAssociationOutcomeCallable CreateDirectConnectGatewayAssociationCallable(const Model::CreateDirectConnectGatewayAssociationRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateDirectConnectGatewayAssociationAsync(const Model::CreateDirectConnectGatewayAssociationRequest& request, const CreateDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Creates a proposal to associate the specified virtual private gateway or * transit gateway with the specified Direct Connect gateway.

You can * associate a Direct Connect gateway and virtual private gateway or transit * gateway that is owned by any AWS account.

See Also:

AWS * API Reference

*/ virtual Model::CreateDirectConnectGatewayAssociationProposalOutcome CreateDirectConnectGatewayAssociationProposal(const Model::CreateDirectConnectGatewayAssociationProposalRequest& request) const; /** *

Creates a proposal to associate the specified virtual private gateway or * transit gateway with the specified Direct Connect gateway.

You can * associate a Direct Connect gateway and virtual private gateway or transit * gateway that is owned by any AWS account.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateDirectConnectGatewayAssociationProposalOutcomeCallable CreateDirectConnectGatewayAssociationProposalCallable(const Model::CreateDirectConnectGatewayAssociationProposalRequest& request) const; /** *

Creates a proposal to associate the specified virtual private gateway or * transit gateway with the specified Direct Connect gateway.

You can * associate a Direct Connect gateway and virtual private gateway or transit * gateway that is owned by any AWS account.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateDirectConnectGatewayAssociationProposalAsync(const Model::CreateDirectConnectGatewayAssociationProposalRequest& request, const CreateDirectConnectGatewayAssociationProposalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Creates an interconnect between an AWS Direct Connect Partner's network and a * specific AWS Direct Connect location.

An interconnect is a connection * that is capable of hosting other connections. The AWS Direct Connect partner can * use an interconnect to provide AWS Direct Connect hosted connections to * customers through their own network services. Like a standard connection, an * interconnect links the partner's network to an AWS Direct Connect location over * a standard Ethernet fiber-optic cable. One end is connected to the partner's * router, the other to an AWS Direct Connect router.

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 AWS 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.

For each end customer, the AWS Direct Connect Partner provisions * a connection on their interconnect by calling AllocateHostedConnection. * The end customer can then connect to AWS resources by creating a virtual * interface on their connection, using the VLAN assigned to them by the AWS Direct * Connect Partner.

Intended for use by AWS Direct Connect Partners * only.

See Also:

AWS * API Reference

*/ virtual Model::CreateInterconnectOutcome CreateInterconnect(const Model::CreateInterconnectRequest& request) const; /** *

Creates an interconnect between an AWS Direct Connect Partner's network and a * specific AWS Direct Connect location.

An interconnect is a connection * that is capable of hosting other connections. The AWS Direct Connect partner can * use an interconnect to provide AWS Direct Connect hosted connections to * customers through their own network services. Like a standard connection, an * interconnect links the partner's network to an AWS Direct Connect location over * a standard Ethernet fiber-optic cable. One end is connected to the partner's * router, the other to an AWS Direct Connect router.

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 AWS 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.

For each end customer, the AWS Direct Connect Partner provisions * a connection on their interconnect by calling AllocateHostedConnection. * The end customer can then connect to AWS resources by creating a virtual * interface on their connection, using the VLAN assigned to them by the AWS Direct * Connect Partner.

Intended for use by AWS Direct Connect Partners * only.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateInterconnectOutcomeCallable CreateInterconnectCallable(const Model::CreateInterconnectRequest& request) const; /** *

Creates an interconnect between an AWS Direct Connect Partner's network and a * specific AWS Direct Connect location.

An interconnect is a connection * that is capable of hosting other connections. The AWS Direct Connect partner can * use an interconnect to provide AWS Direct Connect hosted connections to * customers through their own network services. Like a standard connection, an * interconnect links the partner's network to an AWS Direct Connect location over * a standard Ethernet fiber-optic cable. One end is connected to the partner's * router, the other to an AWS Direct Connect router.

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 AWS 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.

For each end customer, the AWS Direct Connect Partner provisions * a connection on their interconnect by calling AllocateHostedConnection. * The end customer can then connect to AWS resources by creating a virtual * interface on their connection, using the VLAN assigned to them by the AWS Direct * Connect Partner.

Intended for use by AWS Direct Connect Partners * only.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateInterconnectAsync(const Model::CreateInterconnectRequest& request, const CreateInterconnectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Creates a link aggregation group (LAG) with the specified number of bundled * physical connections between the customer network and a specific AWS 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.

All connections in a LAG must use the same * bandwidth and must terminate at the same AWS Direct Connect endpoint.

You * can have up to 10 connections per LAG. Regardless of this limit, if you request * more connections for the LAG than AWS Direct Connect can allocate on a single * endpoint, no LAG is created.

You can specify an existing physical * connection or interconnect to include in the LAG (which counts towards the total * number of connections). Doing so interrupts the current physical connection or * hosted connections, and re-establishes them as a member of the LAG. The LAG will * be created on the same AWS Direct Connect endpoint to which the connection * terminates. Any virtual interfaces associated with the connection are * automatically disassociated and re-associated with the LAG. The connection ID * does not change.

If the AWS account used to create a LAG is a registered * AWS 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.

See Also:

AWS * API Reference

*/ virtual Model::CreateLagOutcome CreateLag(const Model::CreateLagRequest& request) const; /** *

Creates a link aggregation group (LAG) with the specified number of bundled * physical connections between the customer network and a specific AWS 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.

All connections in a LAG must use the same * bandwidth and must terminate at the same AWS Direct Connect endpoint.

You * can have up to 10 connections per LAG. Regardless of this limit, if you request * more connections for the LAG than AWS Direct Connect can allocate on a single * endpoint, no LAG is created.

You can specify an existing physical * connection or interconnect to include in the LAG (which counts towards the total * number of connections). Doing so interrupts the current physical connection or * hosted connections, and re-establishes them as a member of the LAG. The LAG will * be created on the same AWS Direct Connect endpoint to which the connection * terminates. Any virtual interfaces associated with the connection are * automatically disassociated and re-associated with the LAG. The connection ID * does not change.

If the AWS account used to create a LAG is a registered * AWS 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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateLagOutcomeCallable CreateLagCallable(const Model::CreateLagRequest& request) const; /** *

Creates a link aggregation group (LAG) with the specified number of bundled * physical connections between the customer network and a specific AWS 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.

All connections in a LAG must use the same * bandwidth and must terminate at the same AWS Direct Connect endpoint.

You * can have up to 10 connections per LAG. Regardless of this limit, if you request * more connections for the LAG than AWS Direct Connect can allocate on a single * endpoint, no LAG is created.

You can specify an existing physical * connection or interconnect to include in the LAG (which counts towards the total * number of connections). Doing so interrupts the current physical connection or * hosted connections, and re-establishes them as a member of the LAG. The LAG will * be created on the same AWS Direct Connect endpoint to which the connection * terminates. Any virtual interfaces associated with the connection are * automatically disassociated and re-associated with the LAG. The connection ID * does not change.

If the AWS account used to create a LAG is a registered * AWS 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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateLagAsync(const Model::CreateLagRequest& request, const CreateLagResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Creates a private virtual interface. A virtual interface is the VLAN that * transports AWS 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 AWS * Regions. Connecting the private virtual interface to a VGW only provides access * to a single VPC within the same Region.

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 DescribeConnections. To check whether your virtual interface * supports jumbo frames, call DescribeVirtualInterfaces.

See * Also:

AWS * API Reference

*/ virtual Model::CreatePrivateVirtualInterfaceOutcome CreatePrivateVirtualInterface(const Model::CreatePrivateVirtualInterfaceRequest& request) const; /** *

Creates a private virtual interface. A virtual interface is the VLAN that * transports AWS 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 AWS * Regions. Connecting the private virtual interface to a VGW only provides access * to a single VPC within the same Region.

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 DescribeConnections. To check whether your virtual interface * supports jumbo frames, call DescribeVirtualInterfaces.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreatePrivateVirtualInterfaceOutcomeCallable CreatePrivateVirtualInterfaceCallable(const Model::CreatePrivateVirtualInterfaceRequest& request) const; /** *

Creates a private virtual interface. A virtual interface is the VLAN that * transports AWS 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 AWS * Regions. Connecting the private virtual interface to a VGW only provides access * to a single VPC within the same Region.

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 DescribeConnections. To check whether your virtual interface * supports jumbo frames, call DescribeVirtualInterfaces.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreatePrivateVirtualInterfaceAsync(const Model::CreatePrivateVirtualInterfaceRequest& request, const CreatePrivateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Creates a public virtual interface. A virtual interface is the VLAN that * transports AWS Direct Connect traffic. A public virtual interface supports * sending traffic to public services of AWS such as Amazon S3.

When * creating an IPv6 public virtual interface (addressFamily is * ipv6), leave the customer and amazon * address fields blank to use auto-assigned IPv6 space. Custom IPv6 addresses are * not supported.

See Also:

AWS * API Reference

*/ virtual Model::CreatePublicVirtualInterfaceOutcome CreatePublicVirtualInterface(const Model::CreatePublicVirtualInterfaceRequest& request) const; /** *

Creates a public virtual interface. A virtual interface is the VLAN that * transports AWS Direct Connect traffic. A public virtual interface supports * sending traffic to public services of AWS such as Amazon S3.

When * creating an IPv6 public virtual interface (addressFamily is * ipv6), leave the customer and amazon * address fields blank to use auto-assigned IPv6 space. Custom IPv6 addresses are * not supported.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreatePublicVirtualInterfaceOutcomeCallable CreatePublicVirtualInterfaceCallable(const Model::CreatePublicVirtualInterfaceRequest& request) const; /** *

Creates a public virtual interface. A virtual interface is the VLAN that * transports AWS Direct Connect traffic. A public virtual interface supports * sending traffic to public services of AWS such as Amazon S3.

When * creating an IPv6 public virtual interface (addressFamily is * ipv6), leave the customer and amazon * address fields blank to use auto-assigned IPv6 space. Custom IPv6 addresses are * not supported.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreatePublicVirtualInterfaceAsync(const Model::CreatePublicVirtualInterfaceRequest& request, const CreatePublicVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

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.

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 DescribeConnections. To check whether your virtual interface * supports jumbo frames, call DescribeVirtualInterfaces.

See * Also:

AWS * API Reference

*/ virtual Model::CreateTransitVirtualInterfaceOutcome CreateTransitVirtualInterface(const Model::CreateTransitVirtualInterfaceRequest& request) const; /** *

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.

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.

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 DescribeConnections. To check whether your virtual interface * supports jumbo frames, call DescribeVirtualInterfaces.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateTransitVirtualInterfaceOutcomeCallable CreateTransitVirtualInterfaceCallable(const Model::CreateTransitVirtualInterfaceRequest& request) const; /** *

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.

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.

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 DescribeConnections. To check whether your virtual interface * supports jumbo frames, call DescribeVirtualInterfaces.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateTransitVirtualInterfaceAsync(const Model::CreateTransitVirtualInterfaceRequest& request, const CreateTransitVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Deletes the specified BGP peer on the specified virtual interface with the * specified customer address and ASN.

You cannot delete the last BGP peer * from a virtual interface.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBGPPeerOutcome DeleteBGPPeer(const Model::DeleteBGPPeerRequest& request) const; /** *

Deletes the specified BGP peer on the specified virtual interface with the * specified customer address and ASN.

You cannot delete the last BGP peer * from a virtual interface.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteBGPPeerOutcomeCallable DeleteBGPPeerCallable(const Model::DeleteBGPPeerRequest& request) const; /** *

Deletes the specified BGP peer on the specified virtual interface with the * specified customer address and ASN.

You cannot delete the last BGP peer * from a virtual interface.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteBGPPeerAsync(const Model::DeleteBGPPeerRequest& request, const DeleteBGPPeerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Deletes the specified connection.

Deleting a connection only stops the * AWS Direct Connect port hour and data transfer charges. If you are partnering * with any third parties to connect with the AWS Direct Connect location, you must * cancel your service with them separately.

See Also:

AWS * API Reference

*/ virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const; /** *

Deletes the specified connection.

Deleting a connection only stops the * AWS Direct Connect port hour and data transfer charges. If you are partnering * with any third parties to connect with the AWS Direct Connect location, you must * cancel your service with them separately.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const Model::DeleteConnectionRequest& request) const; /** *

Deletes the specified connection.

Deleting a connection only stops the * AWS Direct Connect port hour and data transfer charges. If you are partnering * with any third parties to connect with the AWS Direct Connect location, you must * cancel your service with them separately.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteConnectionAsync(const Model::DeleteConnectionRequest& request, const DeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDirectConnectGatewayOutcome DeleteDirectConnectGateway(const Model::DeleteDirectConnectGatewayRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteDirectConnectGatewayOutcomeCallable DeleteDirectConnectGatewayCallable(const Model::DeleteDirectConnectGatewayRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteDirectConnectGatewayAsync(const Model::DeleteDirectConnectGatewayRequest& request, const DeleteDirectConnectGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Deletes the association between the specified Direct Connect gateway and * virtual private gateway.

We recommend that you specify the * associationID to delete the association. Alternatively, if you own * virtual gateway and a Direct Connect gateway association, you can specify the * virtualGatewayId and directConnectGatewayId to delete * an association.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDirectConnectGatewayAssociationOutcome DeleteDirectConnectGatewayAssociation(const Model::DeleteDirectConnectGatewayAssociationRequest& request) const; /** *

Deletes the association between the specified Direct Connect gateway and * virtual private gateway.

We recommend that you specify the * associationID to delete the association. Alternatively, if you own * virtual gateway and a Direct Connect gateway association, you can specify the * virtualGatewayId and directConnectGatewayId to delete * an association.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteDirectConnectGatewayAssociationOutcomeCallable DeleteDirectConnectGatewayAssociationCallable(const Model::DeleteDirectConnectGatewayAssociationRequest& request) const; /** *

Deletes the association between the specified Direct Connect gateway and * virtual private gateway.

We recommend that you specify the * associationID to delete the association. Alternatively, if you own * virtual gateway and a Direct Connect gateway association, you can specify the * virtualGatewayId and directConnectGatewayId to delete * an association.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteDirectConnectGatewayAssociationAsync(const Model::DeleteDirectConnectGatewayAssociationRequest& request, const DeleteDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Deletes the association proposal request between the specified Direct Connect * gateway and virtual private gateway or transit gateway.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteDirectConnectGatewayAssociationProposalOutcome DeleteDirectConnectGatewayAssociationProposal(const Model::DeleteDirectConnectGatewayAssociationProposalRequest& request) const; /** *

Deletes the association proposal request between the specified Direct Connect * gateway and virtual private gateway or transit gateway.

See Also:

* AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteDirectConnectGatewayAssociationProposalOutcomeCallable DeleteDirectConnectGatewayAssociationProposalCallable(const Model::DeleteDirectConnectGatewayAssociationProposalRequest& request) const; /** *

Deletes the association proposal request between the specified Direct Connect * gateway and virtual private gateway or transit gateway.

See Also:

* AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteDirectConnectGatewayAssociationProposalAsync(const Model::DeleteDirectConnectGatewayAssociationProposalRequest& request, const DeleteDirectConnectGatewayAssociationProposalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Deletes the specified interconnect.

Intended for use by AWS * Direct Connect Partners only.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInterconnectOutcome DeleteInterconnect(const Model::DeleteInterconnectRequest& request) const; /** *

Deletes the specified interconnect.

Intended for use by AWS * Direct Connect Partners only.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteInterconnectOutcomeCallable DeleteInterconnectCallable(const Model::DeleteInterconnectRequest& request) const; /** *

Deletes the specified interconnect.

Intended for use by AWS * Direct Connect Partners only.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteInterconnectAsync(const Model::DeleteInterconnectRequest& request, const DeleteInterconnectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Deletes the specified link aggregation group (LAG). You cannot delete a LAG * if it has active virtual interfaces or hosted connections.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteLagOutcome DeleteLag(const Model::DeleteLagRequest& request) const; /** *

Deletes the specified link aggregation group (LAG). You cannot delete a LAG * if it has active virtual interfaces or hosted connections.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteLagOutcomeCallable DeleteLagCallable(const Model::DeleteLagRequest& request) const; /** *

Deletes the specified link aggregation group (LAG). You cannot delete a LAG * if it has active virtual interfaces or hosted connections.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteLagAsync(const Model::DeleteLagRequest& request, const DeleteLagResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Deletes a virtual interface.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVirtualInterfaceOutcome DeleteVirtualInterface(const Model::DeleteVirtualInterfaceRequest& request) const; /** *

Deletes a virtual interface.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteVirtualInterfaceOutcomeCallable DeleteVirtualInterfaceCallable(const Model::DeleteVirtualInterfaceRequest& request) const; /** *

Deletes a virtual interface.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteVirtualInterfaceAsync(const Model::DeleteVirtualInterfaceRequest& request, const DeleteVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Displays the specified connection or all connections in this * Region.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConnectionsOutcome DescribeConnections(const Model::DescribeConnectionsRequest& request) const; /** *

Displays the specified connection or all connections in this * Region.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeConnectionsOutcomeCallable DescribeConnectionsCallable(const Model::DescribeConnectionsRequest& request) const; /** *

Displays the specified connection or all connections in this * Region.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeConnectionsAsync(const Model::DescribeConnectionsRequest& request, const DescribeConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Describes one or more association proposals for connection between a virtual * private gateway or transit gateway and a Direct Connect gateway.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeDirectConnectGatewayAssociationProposalsOutcome DescribeDirectConnectGatewayAssociationProposals(const Model::DescribeDirectConnectGatewayAssociationProposalsRequest& request) const; /** *

Describes one or more association proposals for connection between a virtual * private gateway or transit gateway and a Direct Connect gateway.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeDirectConnectGatewayAssociationProposalsOutcomeCallable DescribeDirectConnectGatewayAssociationProposalsCallable(const Model::DescribeDirectConnectGatewayAssociationProposalsRequest& request) const; /** *

Describes one or more association proposals for connection between a virtual * private gateway or transit gateway and a Direct Connect gateway.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeDirectConnectGatewayAssociationProposalsAsync(const Model::DescribeDirectConnectGatewayAssociationProposalsRequest& request, const DescribeDirectConnectGatewayAssociationProposalsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Lists the associations between your Direct Connect gateways and virtual * private gateways. You must specify a Direct Connect gateway, a virtual private * gateway, or both. If you specify a Direct Connect gateway, the response contains * all virtual private gateways associated with the Direct Connect gateway. If you * specify a virtual private gateway, the response contains all Direct Connect * gateways associated with the virtual private gateway. If you specify both, the * response contains the association between the Direct Connect gateway and the * virtual private gateway.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDirectConnectGatewayAssociationsOutcome DescribeDirectConnectGatewayAssociations(const Model::DescribeDirectConnectGatewayAssociationsRequest& request) const; /** *

Lists the associations between your Direct Connect gateways and virtual * private gateways. You must specify a Direct Connect gateway, a virtual private * gateway, or both. If you specify a Direct Connect gateway, the response contains * all virtual private gateways associated with the Direct Connect gateway. If you * specify a virtual private gateway, the response contains all Direct Connect * gateways associated with the virtual private gateway. If you specify both, the * response contains the association between the Direct Connect gateway and the * virtual private gateway.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeDirectConnectGatewayAssociationsOutcomeCallable DescribeDirectConnectGatewayAssociationsCallable(const Model::DescribeDirectConnectGatewayAssociationsRequest& request) const; /** *

Lists the associations between your Direct Connect gateways and virtual * private gateways. You must specify a Direct Connect gateway, a virtual private * gateway, or both. If you specify a Direct Connect gateway, the response contains * all virtual private gateways associated with the Direct Connect gateway. If you * specify a virtual private gateway, the response contains all Direct Connect * gateways associated with the virtual private gateway. If you specify both, the * response contains the association between the Direct Connect gateway and the * virtual private gateway.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeDirectConnectGatewayAssociationsAsync(const Model::DescribeDirectConnectGatewayAssociationsRequest& request, const DescribeDirectConnectGatewayAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeDirectConnectGatewayAttachmentsOutcome DescribeDirectConnectGatewayAttachments(const Model::DescribeDirectConnectGatewayAttachmentsRequest& request) const; /** *

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.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeDirectConnectGatewayAttachmentsOutcomeCallable DescribeDirectConnectGatewayAttachmentsCallable(const Model::DescribeDirectConnectGatewayAttachmentsRequest& request) const; /** *

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.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeDirectConnectGatewayAttachmentsAsync(const Model::DescribeDirectConnectGatewayAttachmentsRequest& request, const DescribeDirectConnectGatewayAttachmentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Lists all your Direct Connect gateways or only the specified Direct Connect * gateway. Deleted Direct Connect gateways are not returned.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeDirectConnectGatewaysOutcome DescribeDirectConnectGateways(const Model::DescribeDirectConnectGatewaysRequest& request) const; /** *

Lists all your Direct Connect gateways or only the specified Direct Connect * gateway. Deleted Direct Connect gateways are not returned.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeDirectConnectGatewaysOutcomeCallable DescribeDirectConnectGatewaysCallable(const Model::DescribeDirectConnectGatewaysRequest& request) const; /** *

Lists all your Direct Connect gateways or only the specified Direct Connect * gateway. Deleted Direct Connect gateways are not returned.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeDirectConnectGatewaysAsync(const Model::DescribeDirectConnectGatewaysRequest& request, const DescribeDirectConnectGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Lists the hosted connections that have been provisioned on the specified * interconnect or link aggregation group (LAG).

Intended for use by * AWS Direct Connect Partners only.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHostedConnectionsOutcome DescribeHostedConnections(const Model::DescribeHostedConnectionsRequest& request) const; /** *

Lists the hosted connections that have been provisioned on the specified * interconnect or link aggregation group (LAG).

Intended for use by * AWS Direct Connect Partners only.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeHostedConnectionsOutcomeCallable DescribeHostedConnectionsCallable(const Model::DescribeHostedConnectionsRequest& request) const; /** *

Lists the hosted connections that have been provisioned on the specified * interconnect or link aggregation group (LAG).

Intended for use by * AWS Direct Connect Partners only.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeHostedConnectionsAsync(const Model::DescribeHostedConnectionsRequest& request, const DescribeHostedConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Lists the interconnects owned by the AWS account or only the specified * interconnect.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInterconnectsOutcome DescribeInterconnects(const Model::DescribeInterconnectsRequest& request) const; /** *

Lists the interconnects owned by the AWS account or only the specified * interconnect.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeInterconnectsOutcomeCallable DescribeInterconnectsCallable(const Model::DescribeInterconnectsRequest& request) const; /** *

Lists the interconnects owned by the AWS account or only the specified * interconnect.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeInterconnectsAsync(const Model::DescribeInterconnectsRequest& request, const DescribeInterconnectsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Describes all your link aggregation groups (LAG) or the specified * LAG.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLagsOutcome DescribeLags(const Model::DescribeLagsRequest& request) const; /** *

Describes all your link aggregation groups (LAG) or the specified * LAG.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeLagsOutcomeCallable DescribeLagsCallable(const Model::DescribeLagsRequest& request) const; /** *

Describes all your link aggregation groups (LAG) or the specified * LAG.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeLagsAsync(const Model::DescribeLagsRequest& request, const DescribeLagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Gets the LOA-CFA for a connection, interconnect, or link aggregation group * (LAG).

The Letter of Authorization - Connecting Facility Assignment * (LOA-CFA) is a document that is used when establishing your cross connect to AWS * at the colocation facility. For more information, see Requesting * Cross Connects at AWS Direct Connect Locations in the AWS Direct Connect * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLoaOutcome DescribeLoa(const Model::DescribeLoaRequest& request) const; /** *

Gets the LOA-CFA for a connection, interconnect, or link aggregation group * (LAG).

The Letter of Authorization - Connecting Facility Assignment * (LOA-CFA) is a document that is used when establishing your cross connect to AWS * at the colocation facility. For more information, see Requesting * Cross Connects at AWS Direct Connect Locations in the AWS Direct Connect * User Guide.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeLoaOutcomeCallable DescribeLoaCallable(const Model::DescribeLoaRequest& request) const; /** *

Gets the LOA-CFA for a connection, interconnect, or link aggregation group * (LAG).

The Letter of Authorization - Connecting Facility Assignment * (LOA-CFA) is a document that is used when establishing your cross connect to AWS * at the colocation facility. For more information, see Requesting * Cross Connects at AWS Direct Connect Locations in the AWS Direct Connect * User Guide.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeLoaAsync(const Model::DescribeLoaRequest& request, const DescribeLoaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Lists the AWS Direct Connect locations in the current AWS Region. These are * the locations that can be selected when calling CreateConnection or * CreateInterconnect.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocationsOutcome DescribeLocations() const; /** *

Lists the AWS Direct Connect locations in the current AWS Region. These are * the locations that can be selected when calling CreateConnection or * CreateInterconnect.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeLocationsOutcomeCallable DescribeLocationsCallable() const; /** *

Lists the AWS Direct Connect locations in the current AWS Region. These are * the locations that can be selected when calling CreateConnection or * CreateInterconnect.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeLocationsAsync(const DescribeLocationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Describes the tags associated with the specified AWS Direct Connect * resources.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const; /** *

Describes the tags associated with the specified AWS Direct Connect * resources.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const Model::DescribeTagsRequest& request) const; /** *

Describes the tags associated with the specified AWS Direct Connect * resources.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeTagsAsync(const Model::DescribeTagsRequest& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Lists the virtual private gateways owned by the AWS account.

You can * create one or more AWS Direct Connect private virtual interfaces linked to a * virtual private gateway.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVirtualGatewaysOutcome DescribeVirtualGateways() const; /** *

Lists the virtual private gateways owned by the AWS account.

You can * create one or more AWS Direct Connect private virtual interfaces linked to a * virtual private gateway.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeVirtualGatewaysOutcomeCallable DescribeVirtualGatewaysCallable() const; /** *

Lists the virtual private gateways owned by the AWS account.

You can * create one or more AWS Direct Connect private virtual interfaces linked to a * virtual private gateway.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeVirtualGatewaysAsync(const DescribeVirtualGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Displays all virtual interfaces for an AWS 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.

A virtual interface (VLAN) * transmits the traffic between the AWS Direct Connect location and the customer * network.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVirtualInterfacesOutcome DescribeVirtualInterfaces(const Model::DescribeVirtualInterfacesRequest& request) const; /** *

Displays all virtual interfaces for an AWS 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.

A virtual interface (VLAN) * transmits the traffic between the AWS Direct Connect location and the customer * network.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeVirtualInterfacesOutcomeCallable DescribeVirtualInterfacesCallable(const Model::DescribeVirtualInterfacesRequest& request) const; /** *

Displays all virtual interfaces for an AWS 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.

A virtual interface (VLAN) * transmits the traffic between the AWS Direct Connect location and the customer * network.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeVirtualInterfacesAsync(const Model::DescribeVirtualInterfacesRequest& request, const DescribeVirtualInterfacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 * DeleteConnection request). If the LAG has associated virtual interfaces * or hosted connections, they remain associated with the LAG. A disassociated * connection owned by an AWS Direct Connect Partner is automatically converted to * an interconnect.

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.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateConnectionFromLagOutcome DisassociateConnectionFromLag(const Model::DisassociateConnectionFromLagRequest& request) const; /** *

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 * DeleteConnection request). If the LAG has associated virtual interfaces * or hosted connections, they remain associated with the LAG. A disassociated * connection owned by an AWS Direct Connect Partner is automatically converted to * an interconnect.

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DisassociateConnectionFromLagOutcomeCallable DisassociateConnectionFromLagCallable(const Model::DisassociateConnectionFromLagRequest& request) const; /** *

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 * DeleteConnection request). If the LAG has associated virtual interfaces * or hosted connections, they remain associated with the LAG. A disassociated * connection owned by an AWS Direct Connect Partner is automatically converted to * an interconnect.

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DisassociateConnectionFromLagAsync(const Model::DisassociateConnectionFromLagRequest& request, const DisassociateConnectionFromLagResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Lists the virtual interface failover test history.

See Also:

* AWS * API Reference

*/ virtual Model::ListVirtualInterfaceTestHistoryOutcome ListVirtualInterfaceTestHistory(const Model::ListVirtualInterfaceTestHistoryRequest& request) const; /** *

Lists the virtual interface failover test history.

See Also:

* AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ListVirtualInterfaceTestHistoryOutcomeCallable ListVirtualInterfaceTestHistoryCallable(const Model::ListVirtualInterfaceTestHistoryRequest& request) const; /** *

Lists the virtual interface failover test history.

See Also:

* AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ListVirtualInterfaceTestHistoryAsync(const Model::ListVirtualInterfaceTestHistoryRequest& request, const ListVirtualInterfaceTestHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

*

You can run the test on public, private, transit, and hosted virtual * interfaces.

You can use ListVirtualInterfaceTestHistory * to view the virtual interface test history.

If you need to stop the test * before the test interval completes, use StopBgpFailoverTest.

See * Also:

AWS * API Reference

*/ virtual Model::StartBgpFailoverTestOutcome StartBgpFailoverTest(const Model::StartBgpFailoverTestRequest& request) const; /** *

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.

*

You can run the test on public, private, transit, and hosted virtual * interfaces.

You can use ListVirtualInterfaceTestHistory * to view the virtual interface test history.

If you need to stop the test * before the test interval completes, use StopBgpFailoverTest.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::StartBgpFailoverTestOutcomeCallable StartBgpFailoverTestCallable(const Model::StartBgpFailoverTestRequest& request) const; /** *

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.

*

You can run the test on public, private, transit, and hosted virtual * interfaces.

You can use ListVirtualInterfaceTestHistory * to view the virtual interface test history.

If you need to stop the test * before the test interval completes, use StopBgpFailoverTest.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void StartBgpFailoverTestAsync(const Model::StartBgpFailoverTestRequest& request, const StartBgpFailoverTestResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Stops the virtual interface failover test.

See Also:

AWS * API Reference

*/ virtual Model::StopBgpFailoverTestOutcome StopBgpFailoverTest(const Model::StopBgpFailoverTestRequest& request) const; /** *

Stops the virtual interface failover test.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::StopBgpFailoverTestOutcomeCallable StopBgpFailoverTestCallable(const Model::StopBgpFailoverTestRequest& request) const; /** *

Stops the virtual interface failover test.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void StopBgpFailoverTestAsync(const Model::StopBgpFailoverTestRequest& request, const StopBgpFailoverTestResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Adds the specified tags to the specified AWS Direct Connect resource. Each * resource can have a maximum of 50 tags.

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.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** *

Adds the specified tags to the specified AWS Direct Connect resource. Each * resource can have a maximum of 50 tags.

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const; /** *

Adds the specified tags to the specified AWS Direct Connect resource. Each * resource can have a maximum of 50 tags.

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Removes one or more tags from the specified AWS Direct Connect * resource.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** *

Removes one or more tags from the specified AWS Direct Connect * resource.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const; /** *

Removes one or more tags from the specified AWS Direct Connect * resource.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Updates the specified attributes of the Direct Connect gateway * association.

Add or remove prefixes from the association.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateDirectConnectGatewayAssociationOutcome UpdateDirectConnectGatewayAssociation(const Model::UpdateDirectConnectGatewayAssociationRequest& request) const; /** *

Updates the specified attributes of the Direct Connect gateway * association.

Add or remove prefixes from the association.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateDirectConnectGatewayAssociationOutcomeCallable UpdateDirectConnectGatewayAssociationCallable(const Model::UpdateDirectConnectGatewayAssociationRequest& request) const; /** *

Updates the specified attributes of the Direct Connect gateway * association.

Add or remove prefixes from the association.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateDirectConnectGatewayAssociationAsync(const Model::UpdateDirectConnectGatewayAssociationRequest& request, const UpdateDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Updates the attributes of the specified link aggregation group (LAG).

*

You can update the following attributes:

  • The name of the * LAG.

  • The value for the minimum number of connections that must * be operational for the LAG itself to be operational.

When * you create a LAG, the default value for the minimum number of operational * connections is zero (0). If you update this value and the number of operational * connections falls below the specified value, the LAG automatically goes down to * avoid over-utilization of the remaining connections. Adjust this value with * care, as it could force the LAG down if it is set higher than the current number * of operational connections.

See Also:

AWS * API Reference

*/ virtual Model::UpdateLagOutcome UpdateLag(const Model::UpdateLagRequest& request) const; /** *

Updates the attributes of the specified link aggregation group (LAG).

*

You can update the following attributes:

  • The name of the * LAG.

  • The value for the minimum number of connections that must * be operational for the LAG itself to be operational.

When * you create a LAG, the default value for the minimum number of operational * connections is zero (0). If you update this value and the number of operational * connections falls below the specified value, the LAG automatically goes down to * avoid over-utilization of the remaining connections. Adjust this value with * care, as it could force the LAG down if it is set higher than the current number * of operational connections.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateLagOutcomeCallable UpdateLagCallable(const Model::UpdateLagRequest& request) const; /** *

Updates the attributes of the specified link aggregation group (LAG).

*

You can update the following attributes:

  • The name of the * LAG.

  • The value for the minimum number of connections that must * be operational for the LAG itself to be operational.

When * you create a LAG, the default value for the minimum number of operational * connections is zero (0). If you update this value and the number of operational * connections falls below the specified value, the LAG automatically goes down to * avoid over-utilization of the remaining connections. Adjust this value with * care, as it could force the LAG down if it is set higher than the current number * of operational connections.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateLagAsync(const Model::UpdateLagRequest& request, const UpdateLagResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Updates the specified attributes of the specified virtual private * interface.

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 * DescribeConnections. To check whether your virtual q interface supports * jumbo frames, call DescribeVirtualInterfaces.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateVirtualInterfaceAttributesOutcome UpdateVirtualInterfaceAttributes(const Model::UpdateVirtualInterfaceAttributesRequest& request) const; /** *

Updates the specified attributes of the specified virtual private * interface.

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 * DescribeConnections. To check whether your virtual q interface supports * jumbo frames, call DescribeVirtualInterfaces.

See Also:

* AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateVirtualInterfaceAttributesOutcomeCallable UpdateVirtualInterfaceAttributesCallable(const Model::UpdateVirtualInterfaceAttributesRequest& request) const; /** *

Updates the specified attributes of the specified virtual private * interface.

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 * DescribeConnections. To check whether your virtual q interface supports * jumbo frames, call DescribeVirtualInterfaces.

See Also:

* AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateVirtualInterfaceAttributesAsync(const Model::UpdateVirtualInterfaceAttributesRequest& request, const UpdateVirtualInterfaceAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; void OverrideEndpoint(const Aws::String& endpoint); private: void init(const Aws::Client::ClientConfiguration& clientConfiguration); void AcceptDirectConnectGatewayAssociationProposalAsyncHelper(const Model::AcceptDirectConnectGatewayAssociationProposalRequest& request, const AcceptDirectConnectGatewayAssociationProposalResponseReceivedHandler& handler, const std::shared_ptr& context) const; void AllocateHostedConnectionAsyncHelper(const Model::AllocateHostedConnectionRequest& request, const AllocateHostedConnectionResponseReceivedHandler& handler, const std::shared_ptr& context) const; void AllocatePrivateVirtualInterfaceAsyncHelper(const Model::AllocatePrivateVirtualInterfaceRequest& request, const AllocatePrivateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void AllocatePublicVirtualInterfaceAsyncHelper(const Model::AllocatePublicVirtualInterfaceRequest& request, const AllocatePublicVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void AllocateTransitVirtualInterfaceAsyncHelper(const Model::AllocateTransitVirtualInterfaceRequest& request, const AllocateTransitVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void AssociateConnectionWithLagAsyncHelper(const Model::AssociateConnectionWithLagRequest& request, const AssociateConnectionWithLagResponseReceivedHandler& handler, const std::shared_ptr& context) const; void AssociateHostedConnectionAsyncHelper(const Model::AssociateHostedConnectionRequest& request, const AssociateHostedConnectionResponseReceivedHandler& handler, const std::shared_ptr& context) const; void AssociateVirtualInterfaceAsyncHelper(const Model::AssociateVirtualInterfaceRequest& request, const AssociateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ConfirmConnectionAsyncHelper(const Model::ConfirmConnectionRequest& request, const ConfirmConnectionResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ConfirmPrivateVirtualInterfaceAsyncHelper(const Model::ConfirmPrivateVirtualInterfaceRequest& request, const ConfirmPrivateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ConfirmPublicVirtualInterfaceAsyncHelper(const Model::ConfirmPublicVirtualInterfaceRequest& request, const ConfirmPublicVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ConfirmTransitVirtualInterfaceAsyncHelper(const Model::ConfirmTransitVirtualInterfaceRequest& request, const ConfirmTransitVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateBGPPeerAsyncHelper(const Model::CreateBGPPeerRequest& request, const CreateBGPPeerResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateConnectionAsyncHelper(const Model::CreateConnectionRequest& request, const CreateConnectionResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateDirectConnectGatewayAsyncHelper(const Model::CreateDirectConnectGatewayRequest& request, const CreateDirectConnectGatewayResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateDirectConnectGatewayAssociationAsyncHelper(const Model::CreateDirectConnectGatewayAssociationRequest& request, const CreateDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateDirectConnectGatewayAssociationProposalAsyncHelper(const Model::CreateDirectConnectGatewayAssociationProposalRequest& request, const CreateDirectConnectGatewayAssociationProposalResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateInterconnectAsyncHelper(const Model::CreateInterconnectRequest& request, const CreateInterconnectResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateLagAsyncHelper(const Model::CreateLagRequest& request, const CreateLagResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreatePrivateVirtualInterfaceAsyncHelper(const Model::CreatePrivateVirtualInterfaceRequest& request, const CreatePrivateVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreatePublicVirtualInterfaceAsyncHelper(const Model::CreatePublicVirtualInterfaceRequest& request, const CreatePublicVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateTransitVirtualInterfaceAsyncHelper(const Model::CreateTransitVirtualInterfaceRequest& request, const CreateTransitVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteBGPPeerAsyncHelper(const Model::DeleteBGPPeerRequest& request, const DeleteBGPPeerResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteConnectionAsyncHelper(const Model::DeleteConnectionRequest& request, const DeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteDirectConnectGatewayAsyncHelper(const Model::DeleteDirectConnectGatewayRequest& request, const DeleteDirectConnectGatewayResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteDirectConnectGatewayAssociationAsyncHelper(const Model::DeleteDirectConnectGatewayAssociationRequest& request, const DeleteDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteDirectConnectGatewayAssociationProposalAsyncHelper(const Model::DeleteDirectConnectGatewayAssociationProposalRequest& request, const DeleteDirectConnectGatewayAssociationProposalResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteInterconnectAsyncHelper(const Model::DeleteInterconnectRequest& request, const DeleteInterconnectResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteLagAsyncHelper(const Model::DeleteLagRequest& request, const DeleteLagResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteVirtualInterfaceAsyncHelper(const Model::DeleteVirtualInterfaceRequest& request, const DeleteVirtualInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeConnectionsAsyncHelper(const Model::DescribeConnectionsRequest& request, const DescribeConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeDirectConnectGatewayAssociationProposalsAsyncHelper(const Model::DescribeDirectConnectGatewayAssociationProposalsRequest& request, const DescribeDirectConnectGatewayAssociationProposalsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeDirectConnectGatewayAssociationsAsyncHelper(const Model::DescribeDirectConnectGatewayAssociationsRequest& request, const DescribeDirectConnectGatewayAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeDirectConnectGatewayAttachmentsAsyncHelper(const Model::DescribeDirectConnectGatewayAttachmentsRequest& request, const DescribeDirectConnectGatewayAttachmentsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeDirectConnectGatewaysAsyncHelper(const Model::DescribeDirectConnectGatewaysRequest& request, const DescribeDirectConnectGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeHostedConnectionsAsyncHelper(const Model::DescribeHostedConnectionsRequest& request, const DescribeHostedConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeInterconnectsAsyncHelper(const Model::DescribeInterconnectsRequest& request, const DescribeInterconnectsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeLagsAsyncHelper(const Model::DescribeLagsRequest& request, const DescribeLagsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeLoaAsyncHelper(const Model::DescribeLoaRequest& request, const DescribeLoaResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeLocationsAsyncHelper(const DescribeLocationsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeTagsAsyncHelper(const Model::DescribeTagsRequest& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeVirtualGatewaysAsyncHelper(const DescribeVirtualGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeVirtualInterfacesAsyncHelper(const Model::DescribeVirtualInterfacesRequest& request, const DescribeVirtualInterfacesResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DisassociateConnectionFromLagAsyncHelper(const Model::DisassociateConnectionFromLagRequest& request, const DisassociateConnectionFromLagResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ListVirtualInterfaceTestHistoryAsyncHelper(const Model::ListVirtualInterfaceTestHistoryRequest& request, const ListVirtualInterfaceTestHistoryResponseReceivedHandler& handler, const std::shared_ptr& context) const; void StartBgpFailoverTestAsyncHelper(const Model::StartBgpFailoverTestRequest& request, const StartBgpFailoverTestResponseReceivedHandler& handler, const std::shared_ptr& context) const; void StopBgpFailoverTestAsyncHelper(const Model::StopBgpFailoverTestRequest& request, const StopBgpFailoverTestResponseReceivedHandler& handler, const std::shared_ptr& context) const; void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateDirectConnectGatewayAssociationAsyncHelper(const Model::UpdateDirectConnectGatewayAssociationRequest& request, const UpdateDirectConnectGatewayAssociationResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateLagAsyncHelper(const Model::UpdateLagRequest& request, const UpdateLagResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateVirtualInterfaceAttributesAsyncHelper(const Model::UpdateVirtualInterfaceAttributesRequest& request, const UpdateVirtualInterfaceAttributesResponseReceivedHandler& handler, const std::shared_ptr& context) const; Aws::String m_uri; Aws::String m_configScheme; std::shared_ptr m_executor; }; } // namespace DirectConnect } // namespace Aws