/** * 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 namespace Aws { namespace EC2 { /** * Amazon Elastic Compute Cloud

Amazon Elastic Compute * Cloud (Amazon EC2) provides secure and resizable computing capacity in the * Amazon Web Services Cloud. Using Amazon EC2 eliminates the need to invest in * hardware up front, so you can develop and deploy applications faster. Amazon * Virtual Private Cloud (Amazon VPC) enables you to provision a logically isolated * section of the Amazon Web Services Cloud where you can launch Amazon Web * Services resources in a virtual network that you've defined. Amazon Elastic * Block Store (Amazon EBS) provides block level storage volumes for use with EC2 * instances. EBS volumes are highly available and reliable storage volumes that * can be attached to any running instance and used like a hard drive.

To * learn more, see the following resources:

*/ class AWS_EC2_API EC2Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef EC2ClientConfiguration ClientConfigurationType; typedef EC2EndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ EC2Client(const Aws::EC2::EC2ClientConfiguration& clientConfiguration = Aws::EC2::EC2ClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ EC2Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::EC2::EC2ClientConfiguration& clientConfiguration = Aws::EC2::EC2ClientConfiguration()); /** * 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 */ EC2Client(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::EC2::EC2ClientConfiguration& clientConfiguration = Aws::EC2::EC2ClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ EC2Client(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ EC2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ EC2Client(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~EC2Client(); /** *

Accepts an Elastic IP address transfer. For more information, see Accept * a transferred Elastic IP address in the Amazon Virtual Private Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::AcceptAddressTransferOutcome AcceptAddressTransfer(const Model::AcceptAddressTransferRequest& request) const; /** * A Callable wrapper for AcceptAddressTransfer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptAddressTransferOutcomeCallable AcceptAddressTransferCallable(const AcceptAddressTransferRequestT& request) const { return SubmitCallable(&EC2Client::AcceptAddressTransfer, request); } /** * An Async wrapper for AcceptAddressTransfer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptAddressTransferAsync(const AcceptAddressTransferRequestT& request, const AcceptAddressTransferResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AcceptAddressTransfer, request, handler, context); } /** *

Accepts the Convertible Reserved Instance exchange quote described in the * GetReservedInstancesExchangeQuote call.

See Also:

AWS * API Reference

*/ virtual Model::AcceptReservedInstancesExchangeQuoteOutcome AcceptReservedInstancesExchangeQuote(const Model::AcceptReservedInstancesExchangeQuoteRequest& request) const; /** * A Callable wrapper for AcceptReservedInstancesExchangeQuote that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptReservedInstancesExchangeQuoteOutcomeCallable AcceptReservedInstancesExchangeQuoteCallable(const AcceptReservedInstancesExchangeQuoteRequestT& request) const { return SubmitCallable(&EC2Client::AcceptReservedInstancesExchangeQuote, request); } /** * An Async wrapper for AcceptReservedInstancesExchangeQuote that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptReservedInstancesExchangeQuoteAsync(const AcceptReservedInstancesExchangeQuoteRequestT& request, const AcceptReservedInstancesExchangeQuoteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AcceptReservedInstancesExchangeQuote, request, handler, context); } /** *

Accepts a request to associate subnets with a transit gateway multicast * domain.

See Also:

AWS * API Reference

*/ virtual Model::AcceptTransitGatewayMulticastDomainAssociationsOutcome AcceptTransitGatewayMulticastDomainAssociations(const Model::AcceptTransitGatewayMulticastDomainAssociationsRequest& request) const; /** * A Callable wrapper for AcceptTransitGatewayMulticastDomainAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptTransitGatewayMulticastDomainAssociationsOutcomeCallable AcceptTransitGatewayMulticastDomainAssociationsCallable(const AcceptTransitGatewayMulticastDomainAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::AcceptTransitGatewayMulticastDomainAssociations, request); } /** * An Async wrapper for AcceptTransitGatewayMulticastDomainAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptTransitGatewayMulticastDomainAssociationsAsync(const AcceptTransitGatewayMulticastDomainAssociationsRequestT& request, const AcceptTransitGatewayMulticastDomainAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AcceptTransitGatewayMulticastDomainAssociations, request, handler, context); } /** *

Accepts a transit gateway peering attachment request. The peering attachment * must be in the pendingAcceptance state.

See Also:

* AWS * API Reference

*/ virtual Model::AcceptTransitGatewayPeeringAttachmentOutcome AcceptTransitGatewayPeeringAttachment(const Model::AcceptTransitGatewayPeeringAttachmentRequest& request) const; /** * A Callable wrapper for AcceptTransitGatewayPeeringAttachment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptTransitGatewayPeeringAttachmentOutcomeCallable AcceptTransitGatewayPeeringAttachmentCallable(const AcceptTransitGatewayPeeringAttachmentRequestT& request) const { return SubmitCallable(&EC2Client::AcceptTransitGatewayPeeringAttachment, request); } /** * An Async wrapper for AcceptTransitGatewayPeeringAttachment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptTransitGatewayPeeringAttachmentAsync(const AcceptTransitGatewayPeeringAttachmentRequestT& request, const AcceptTransitGatewayPeeringAttachmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AcceptTransitGatewayPeeringAttachment, request, handler, context); } /** *

Accepts a request to attach a VPC to a transit gateway.

The VPC * attachment must be in the pendingAcceptance state. Use * DescribeTransitGatewayVpcAttachments to view your pending VPC attachment * requests. Use RejectTransitGatewayVpcAttachment to reject a VPC * attachment request.

See Also:

AWS * API Reference

*/ virtual Model::AcceptTransitGatewayVpcAttachmentOutcome AcceptTransitGatewayVpcAttachment(const Model::AcceptTransitGatewayVpcAttachmentRequest& request) const; /** * A Callable wrapper for AcceptTransitGatewayVpcAttachment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptTransitGatewayVpcAttachmentOutcomeCallable AcceptTransitGatewayVpcAttachmentCallable(const AcceptTransitGatewayVpcAttachmentRequestT& request) const { return SubmitCallable(&EC2Client::AcceptTransitGatewayVpcAttachment, request); } /** * An Async wrapper for AcceptTransitGatewayVpcAttachment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptTransitGatewayVpcAttachmentAsync(const AcceptTransitGatewayVpcAttachmentRequestT& request, const AcceptTransitGatewayVpcAttachmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AcceptTransitGatewayVpcAttachment, request, handler, context); } /** *

Accepts connection requests to your VPC endpoint service.

See * Also:

AWS * API Reference

*/ virtual Model::AcceptVpcEndpointConnectionsOutcome AcceptVpcEndpointConnections(const Model::AcceptVpcEndpointConnectionsRequest& request) const; /** * A Callable wrapper for AcceptVpcEndpointConnections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptVpcEndpointConnectionsOutcomeCallable AcceptVpcEndpointConnectionsCallable(const AcceptVpcEndpointConnectionsRequestT& request) const { return SubmitCallable(&EC2Client::AcceptVpcEndpointConnections, request); } /** * An Async wrapper for AcceptVpcEndpointConnections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptVpcEndpointConnectionsAsync(const AcceptVpcEndpointConnectionsRequestT& request, const AcceptVpcEndpointConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AcceptVpcEndpointConnections, request, handler, context); } /** *

Accept a VPC peering connection request. To accept a request, the VPC peering * connection must be in the pending-acceptance state, and you must be * the owner of the peer VPC. Use DescribeVpcPeeringConnections to view your * outstanding VPC peering connection requests.

For an inter-Region VPC * peering connection request, you must accept the VPC peering connection in the * Region of the accepter VPC.

See Also:

AWS * API Reference

*/ virtual Model::AcceptVpcPeeringConnectionOutcome AcceptVpcPeeringConnection(const Model::AcceptVpcPeeringConnectionRequest& request) const; /** * A Callable wrapper for AcceptVpcPeeringConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptVpcPeeringConnectionOutcomeCallable AcceptVpcPeeringConnectionCallable(const AcceptVpcPeeringConnectionRequestT& request) const { return SubmitCallable(&EC2Client::AcceptVpcPeeringConnection, request); } /** * An Async wrapper for AcceptVpcPeeringConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptVpcPeeringConnectionAsync(const AcceptVpcPeeringConnectionRequestT& request, const AcceptVpcPeeringConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AcceptVpcPeeringConnection, request, handler, context); } /** *

Advertises an IPv4 or IPv6 address range that is provisioned for use with * your Amazon Web Services resources through bring your own IP addresses * (BYOIP).

You can perform this operation at most once every 10 seconds, * even if you specify different address ranges each time.

We recommend that * you stop advertising the BYOIP CIDR from other locations when you advertise it * from Amazon Web Services. To minimize down time, you can configure your Amazon * Web Services resources to use an address from a BYOIP CIDR before it is * advertised, and then simultaneously stop advertising it from the current * location and start advertising it through Amazon Web Services.

It can * take a few minutes before traffic to the specified addresses starts routing to * Amazon Web Services because of BGP propagation delays.

To stop * advertising the BYOIP CIDR, use WithdrawByoipCidr.

See * Also:

AWS * API Reference

*/ virtual Model::AdvertiseByoipCidrOutcome AdvertiseByoipCidr(const Model::AdvertiseByoipCidrRequest& request) const; /** * A Callable wrapper for AdvertiseByoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AdvertiseByoipCidrOutcomeCallable AdvertiseByoipCidrCallable(const AdvertiseByoipCidrRequestT& request) const { return SubmitCallable(&EC2Client::AdvertiseByoipCidr, request); } /** * An Async wrapper for AdvertiseByoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AdvertiseByoipCidrAsync(const AdvertiseByoipCidrRequestT& request, const AdvertiseByoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AdvertiseByoipCidr, request, handler, context); } /** *

Allocates an Elastic IP address to your Amazon Web Services account. After * you allocate the Elastic IP address you can associate it with an instance or * network interface. After you release an Elastic IP address, it is released to * the IP address pool and can be allocated to a different Amazon Web Services * account.

You can allocate an Elastic IP address from an address pool * owned by Amazon Web Services or from an address pool created from a public IPv4 * address range that you have brought to Amazon Web Services for use with your * Amazon Web Services resources using bring your own IP addresses (BYOIP). For * more information, see Bring * Your Own IP Addresses (BYOIP) in the Amazon Elastic Compute Cloud User * Guide.

If you release an Elastic IP address, you might be able to * recover it. You cannot recover an Elastic IP address that you released after it * is allocated to another Amazon Web Services account. To attempt to recover an * Elastic IP address that you released, specify it in this operation.

For * more information, see Elastic * IP Addresses in the Amazon Elastic Compute Cloud User Guide.

*

You can allocate a carrier IP address which is a public IP address from a * telecommunication carrier, to a network interface which resides in a subnet in a * Wavelength Zone (for example an EC2 instance).

See Also:

AWS * API Reference

*/ virtual Model::AllocateAddressOutcome AllocateAddress(const Model::AllocateAddressRequest& request) const; /** * A Callable wrapper for AllocateAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AllocateAddressOutcomeCallable AllocateAddressCallable(const AllocateAddressRequestT& request) const { return SubmitCallable(&EC2Client::AllocateAddress, request); } /** * An Async wrapper for AllocateAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AllocateAddressAsync(const AllocateAddressRequestT& request, const AllocateAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AllocateAddress, request, handler, context); } /** *

Allocates a Dedicated Host to your account. At a minimum, specify the * supported instance type or instance family, the Availability Zone in which to * allocate the host, and the number of hosts to allocate.

See Also:

* AWS * API Reference

*/ virtual Model::AllocateHostsOutcome AllocateHosts(const Model::AllocateHostsRequest& request) const; /** * A Callable wrapper for AllocateHosts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AllocateHostsOutcomeCallable AllocateHostsCallable(const AllocateHostsRequestT& request) const { return SubmitCallable(&EC2Client::AllocateHosts, request); } /** * An Async wrapper for AllocateHosts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AllocateHostsAsync(const AllocateHostsRequestT& request, const AllocateHostsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AllocateHosts, request, handler, context); } /** *

Allocate a CIDR from an IPAM pool. The Region you use should be the IPAM pool * locale. The locale is the Amazon Web Services Region where this IPAM pool is * available for allocations.

In IPAM, an allocation is a CIDR assignment * from an IPAM pool to another IPAM pool or to a resource. For more information, * see Allocate * CIDRs in the Amazon VPC IPAM User Guide.

This action * creates an allocation with strong consistency. The returned CIDR will not * overlap with any other allocations from the same pool.

See * Also:

AWS * API Reference

*/ virtual Model::AllocateIpamPoolCidrOutcome AllocateIpamPoolCidr(const Model::AllocateIpamPoolCidrRequest& request) const; /** * A Callable wrapper for AllocateIpamPoolCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AllocateIpamPoolCidrOutcomeCallable AllocateIpamPoolCidrCallable(const AllocateIpamPoolCidrRequestT& request) const { return SubmitCallable(&EC2Client::AllocateIpamPoolCidr, request); } /** * An Async wrapper for AllocateIpamPoolCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AllocateIpamPoolCidrAsync(const AllocateIpamPoolCidrRequestT& request, const AllocateIpamPoolCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AllocateIpamPoolCidr, request, handler, context); } /** *

Applies a security group to the association between the target network and * the Client VPN endpoint. This action replaces the existing security groups with * the specified security groups.

See Also:

AWS * API Reference

*/ virtual Model::ApplySecurityGroupsToClientVpnTargetNetworkOutcome ApplySecurityGroupsToClientVpnTargetNetwork(const Model::ApplySecurityGroupsToClientVpnTargetNetworkRequest& request) const; /** * A Callable wrapper for ApplySecurityGroupsToClientVpnTargetNetwork that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ApplySecurityGroupsToClientVpnTargetNetworkOutcomeCallable ApplySecurityGroupsToClientVpnTargetNetworkCallable(const ApplySecurityGroupsToClientVpnTargetNetworkRequestT& request) const { return SubmitCallable(&EC2Client::ApplySecurityGroupsToClientVpnTargetNetwork, request); } /** * An Async wrapper for ApplySecurityGroupsToClientVpnTargetNetwork that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ApplySecurityGroupsToClientVpnTargetNetworkAsync(const ApplySecurityGroupsToClientVpnTargetNetworkRequestT& request, const ApplySecurityGroupsToClientVpnTargetNetworkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ApplySecurityGroupsToClientVpnTargetNetwork, request, handler, context); } /** *

Assigns one or more IPv6 addresses to the specified network interface. You * can specify one or more specific IPv6 addresses, or you can specify the number * of IPv6 addresses to be automatically assigned from within the subnet's IPv6 * CIDR block range. You can assign as many IPv6 addresses to a network interface * as you can assign private IPv4 addresses, and the limit varies per instance * type. For information, see IP * Addresses Per Network Interface Per Instance Type in the Amazon Elastic * Compute Cloud User Guide.

You must specify either the IPv6 addresses * or the IPv6 address count in the request.

You can optionally use Prefix * Delegation on the network interface. You must specify either the IPV6 Prefix * Delegation prefixes, or the IPv6 Prefix Delegation count. For information, see * * Assigning prefixes to Amazon EC2 network interfaces in the Amazon Elastic * Compute Cloud User Guide.

See Also:

AWS * API Reference

*/ virtual Model::AssignIpv6AddressesOutcome AssignIpv6Addresses(const Model::AssignIpv6AddressesRequest& request) const; /** * A Callable wrapper for AssignIpv6Addresses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssignIpv6AddressesOutcomeCallable AssignIpv6AddressesCallable(const AssignIpv6AddressesRequestT& request) const { return SubmitCallable(&EC2Client::AssignIpv6Addresses, request); } /** * An Async wrapper for AssignIpv6Addresses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssignIpv6AddressesAsync(const AssignIpv6AddressesRequestT& request, const AssignIpv6AddressesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssignIpv6Addresses, request, handler, context); } /** *

Assigns one or more secondary private IP addresses to the specified network * interface.

You can specify one or more specific secondary IP addresses, * or you can specify the number of secondary IP addresses to be automatically * assigned within the subnet's CIDR block range. The number of secondary IP * addresses that you can assign to an instance varies by instance type. For * information about instance types, see Instance * Types in the Amazon Elastic Compute Cloud User Guide. For more * information about Elastic IP addresses, see Elastic * IP Addresses in the Amazon Elastic Compute Cloud User Guide.

*

When you move a secondary private IP address to another network interface, * any Elastic IP address that is associated with the IP address is also moved.

*

Remapping an IP address is an asynchronous operation. When you move an IP * address from one network interface to another, check * network/interfaces/macs/mac/local-ipv4s in the instance metadata to * confirm that the remapping is complete.

You must specify either the IP * addresses or the IP address count in the request.

You can optionally use * Prefix Delegation on the network interface. You must specify either the IPv4 * Prefix Delegation prefixes, or the IPv4 Prefix Delegation count. For * information, see * Assigning prefixes to Amazon EC2 network interfaces in the Amazon Elastic * Compute Cloud User Guide.

See Also:

AWS * API Reference

*/ virtual Model::AssignPrivateIpAddressesOutcome AssignPrivateIpAddresses(const Model::AssignPrivateIpAddressesRequest& request) const; /** * A Callable wrapper for AssignPrivateIpAddresses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssignPrivateIpAddressesOutcomeCallable AssignPrivateIpAddressesCallable(const AssignPrivateIpAddressesRequestT& request) const { return SubmitCallable(&EC2Client::AssignPrivateIpAddresses, request); } /** * An Async wrapper for AssignPrivateIpAddresses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssignPrivateIpAddressesAsync(const AssignPrivateIpAddressesRequestT& request, const AssignPrivateIpAddressesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssignPrivateIpAddresses, request, handler, context); } /** *

Assigns one or more private IPv4 addresses to a private NAT gateway. For more * information, see Work * with NAT gateways in the Amazon VPC User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::AssignPrivateNatGatewayAddressOutcome AssignPrivateNatGatewayAddress(const Model::AssignPrivateNatGatewayAddressRequest& request) const; /** * A Callable wrapper for AssignPrivateNatGatewayAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssignPrivateNatGatewayAddressOutcomeCallable AssignPrivateNatGatewayAddressCallable(const AssignPrivateNatGatewayAddressRequestT& request) const { return SubmitCallable(&EC2Client::AssignPrivateNatGatewayAddress, request); } /** * An Async wrapper for AssignPrivateNatGatewayAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssignPrivateNatGatewayAddressAsync(const AssignPrivateNatGatewayAddressRequestT& request, const AssignPrivateNatGatewayAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssignPrivateNatGatewayAddress, request, handler, context); } /** *

Associates an Elastic IP address, or carrier IP address (for instances that * are in subnets in Wavelength Zones) with an instance or a network interface. * Before you can use an Elastic IP address, you must allocate it to your * account.

If the Elastic IP address is already associated with a different * instance, it is disassociated from that instance and associated with the * specified instance. If you associate an Elastic IP address with an instance that * has an existing Elastic IP address, the existing address is disassociated from * the instance, but remains allocated to your account.

[Subnets in * Wavelength Zones] You can associate an IP address from the telecommunication * carrier to the instance or network interface.

You cannot associate an * Elastic IP address with an interface in a different network border group.

*

This is an idempotent operation. If you perform the operation * more than once, Amazon EC2 doesn't return an error, and you may be charged for * each time the Elastic IP address is remapped to the same instance. For more * information, see the Elastic IP Addresses section of Amazon EC2 Pricing.

*

See Also:

AWS * API Reference

*/ virtual Model::AssociateAddressOutcome AssociateAddress(const Model::AssociateAddressRequest& request) const; /** * A Callable wrapper for AssociateAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateAddressOutcomeCallable AssociateAddressCallable(const AssociateAddressRequestT& request) const { return SubmitCallable(&EC2Client::AssociateAddress, request); } /** * An Async wrapper for AssociateAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateAddressAsync(const AssociateAddressRequestT& request, const AssociateAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateAddress, request, handler, context); } /** *

Associates a target network with a Client VPN endpoint. A target network is a * subnet in a VPC. You can associate multiple subnets from the same VPC with a * Client VPN endpoint. You can associate only one subnet in each Availability * Zone. We recommend that you associate at least two subnets to provide * Availability Zone redundancy.

If you specified a VPC when you created the * Client VPN endpoint or if you have previous subnet associations, the specified * subnet must be in the same VPC. To specify a subnet that's in a different VPC, * you must first modify the Client VPN endpoint (ModifyClientVpnEndpoint) * and change the VPC that's associated with it.

See Also:

AWS * API Reference

*/ virtual Model::AssociateClientVpnTargetNetworkOutcome AssociateClientVpnTargetNetwork(const Model::AssociateClientVpnTargetNetworkRequest& request) const; /** * A Callable wrapper for AssociateClientVpnTargetNetwork that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateClientVpnTargetNetworkOutcomeCallable AssociateClientVpnTargetNetworkCallable(const AssociateClientVpnTargetNetworkRequestT& request) const { return SubmitCallable(&EC2Client::AssociateClientVpnTargetNetwork, request); } /** * An Async wrapper for AssociateClientVpnTargetNetwork that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateClientVpnTargetNetworkAsync(const AssociateClientVpnTargetNetworkRequestT& request, const AssociateClientVpnTargetNetworkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateClientVpnTargetNetwork, request, handler, context); } /** *

Associates a set of DHCP options (that you've previously created) with the * specified VPC, or associates no DHCP options with the VPC.

After you * associate the options with the VPC, any existing instances and all new instances * that you launch in that VPC use the options. You don't need to restart or * relaunch the instances. They automatically pick up the changes within a few * hours, depending on how frequently the instance renews its DHCP lease. You can * explicitly renew the lease using the operating system on the instance.

*

For more information, see DHCP * options sets in the Amazon VPC User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::AssociateDhcpOptionsOutcome AssociateDhcpOptions(const Model::AssociateDhcpOptionsRequest& request) const; /** * A Callable wrapper for AssociateDhcpOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateDhcpOptionsOutcomeCallable AssociateDhcpOptionsCallable(const AssociateDhcpOptionsRequestT& request) const { return SubmitCallable(&EC2Client::AssociateDhcpOptions, request); } /** * An Async wrapper for AssociateDhcpOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateDhcpOptionsAsync(const AssociateDhcpOptionsRequestT& request, const AssociateDhcpOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateDhcpOptions, request, handler, context); } /** *

Associates an Identity and Access Management (IAM) role with an Certificate * Manager (ACM) certificate. This enables the certificate to be used by the ACM * for Nitro Enclaves application inside an enclave. For more information, see Certificate * Manager for Nitro Enclaves in the Amazon Web Services Nitro Enclaves User * Guide.

When the IAM role is associated with the ACM certificate, the * certificate, certificate chain, and encrypted private key are placed in an * Amazon S3 location that only the associated IAM role can access. The private key * of the certificate is encrypted with an Amazon Web Services managed key that has * an attached attestation-based key policy.

To enable the IAM role to * access the Amazon S3 object, you must grant it permission to call * s3:GetObject on the Amazon S3 bucket returned by the command. To * enable the IAM role to access the KMS key, you must grant it permission to call * kms:Decrypt on the KMS key returned by the command. For more * information, see * Grant the role permission to access the certificate and encryption key in * the Amazon Web Services Nitro Enclaves User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::AssociateEnclaveCertificateIamRoleOutcome AssociateEnclaveCertificateIamRole(const Model::AssociateEnclaveCertificateIamRoleRequest& request) const; /** * A Callable wrapper for AssociateEnclaveCertificateIamRole that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateEnclaveCertificateIamRoleOutcomeCallable AssociateEnclaveCertificateIamRoleCallable(const AssociateEnclaveCertificateIamRoleRequestT& request) const { return SubmitCallable(&EC2Client::AssociateEnclaveCertificateIamRole, request); } /** * An Async wrapper for AssociateEnclaveCertificateIamRole that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateEnclaveCertificateIamRoleAsync(const AssociateEnclaveCertificateIamRoleRequestT& request, const AssociateEnclaveCertificateIamRoleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateEnclaveCertificateIamRole, request, handler, context); } /** *

Associates an IAM instance profile with a running or stopped instance. You * cannot associate more than one IAM instance profile with an * instance.

See Also:

AWS * API Reference

*/ virtual Model::AssociateIamInstanceProfileOutcome AssociateIamInstanceProfile(const Model::AssociateIamInstanceProfileRequest& request) const; /** * A Callable wrapper for AssociateIamInstanceProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateIamInstanceProfileOutcomeCallable AssociateIamInstanceProfileCallable(const AssociateIamInstanceProfileRequestT& request) const { return SubmitCallable(&EC2Client::AssociateIamInstanceProfile, request); } /** * An Async wrapper for AssociateIamInstanceProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateIamInstanceProfileAsync(const AssociateIamInstanceProfileRequestT& request, const AssociateIamInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateIamInstanceProfile, request, handler, context); } /** *

Associates one or more targets with an event window. Only one type of target * (instance IDs, Dedicated Host IDs, or tags) can be specified with an event * window.

For more information, see Define * event windows for scheduled events in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::AssociateInstanceEventWindowOutcome AssociateInstanceEventWindow(const Model::AssociateInstanceEventWindowRequest& request) const; /** * A Callable wrapper for AssociateInstanceEventWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateInstanceEventWindowOutcomeCallable AssociateInstanceEventWindowCallable(const AssociateInstanceEventWindowRequestT& request) const { return SubmitCallable(&EC2Client::AssociateInstanceEventWindow, request); } /** * An Async wrapper for AssociateInstanceEventWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateInstanceEventWindowAsync(const AssociateInstanceEventWindowRequestT& request, const AssociateInstanceEventWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateInstanceEventWindow, request, handler, context); } /** *

Associates an IPAM resource discovery with an Amazon VPC IPAM. A resource * discovery is an IPAM component that enables IPAM to manage and monitor resources * that belong to the owning account.

See Also:

AWS * API Reference

*/ virtual Model::AssociateIpamResourceDiscoveryOutcome AssociateIpamResourceDiscovery(const Model::AssociateIpamResourceDiscoveryRequest& request) const; /** * A Callable wrapper for AssociateIpamResourceDiscovery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateIpamResourceDiscoveryOutcomeCallable AssociateIpamResourceDiscoveryCallable(const AssociateIpamResourceDiscoveryRequestT& request) const { return SubmitCallable(&EC2Client::AssociateIpamResourceDiscovery, request); } /** * An Async wrapper for AssociateIpamResourceDiscovery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateIpamResourceDiscoveryAsync(const AssociateIpamResourceDiscoveryRequestT& request, const AssociateIpamResourceDiscoveryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateIpamResourceDiscovery, request, handler, context); } /** *

Associates Elastic IP addresses (EIPs) and private IPv4 addresses with a * public NAT gateway. For more information, see Work * with NAT gateways in the Amazon VPC User Guide.

By default, * you can associate up to 2 Elastic IP addresses per public NAT gateway. You can * increase the limit by requesting a quota adjustment. For more information, see * Elastic * IP address quotas in the Amazon VPC User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::AssociateNatGatewayAddressOutcome AssociateNatGatewayAddress(const Model::AssociateNatGatewayAddressRequest& request) const; /** * A Callable wrapper for AssociateNatGatewayAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateNatGatewayAddressOutcomeCallable AssociateNatGatewayAddressCallable(const AssociateNatGatewayAddressRequestT& request) const { return SubmitCallable(&EC2Client::AssociateNatGatewayAddress, request); } /** * An Async wrapper for AssociateNatGatewayAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateNatGatewayAddressAsync(const AssociateNatGatewayAddressRequestT& request, const AssociateNatGatewayAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateNatGatewayAddress, request, handler, context); } /** *

Associates a subnet in your VPC or an internet gateway or virtual private * gateway attached to your VPC with a route table in your VPC. This association * causes traffic from the subnet or gateway to be routed according to the routes * in the route table. The action returns an association ID, which you need in * order to disassociate the route table later. A route table can be associated * with multiple subnets.

For more information, see Route * tables in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::AssociateRouteTableOutcome AssociateRouteTable(const Model::AssociateRouteTableRequest& request) const; /** * A Callable wrapper for AssociateRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateRouteTableOutcomeCallable AssociateRouteTableCallable(const AssociateRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::AssociateRouteTable, request); } /** * An Async wrapper for AssociateRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateRouteTableAsync(const AssociateRouteTableRequestT& request, const AssociateRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateRouteTable, request, handler, context); } /** *

Associates a CIDR block with your subnet. You can only associate a single * IPv6 CIDR block with your subnet. An IPv6 CIDR block must have a prefix length * of /64.

See Also:

AWS * API Reference

*/ virtual Model::AssociateSubnetCidrBlockOutcome AssociateSubnetCidrBlock(const Model::AssociateSubnetCidrBlockRequest& request) const; /** * A Callable wrapper for AssociateSubnetCidrBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateSubnetCidrBlockOutcomeCallable AssociateSubnetCidrBlockCallable(const AssociateSubnetCidrBlockRequestT& request) const { return SubmitCallable(&EC2Client::AssociateSubnetCidrBlock, request); } /** * An Async wrapper for AssociateSubnetCidrBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateSubnetCidrBlockAsync(const AssociateSubnetCidrBlockRequestT& request, const AssociateSubnetCidrBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateSubnetCidrBlock, request, handler, context); } /** *

Associates the specified subnets and transit gateway attachments with the * specified transit gateway multicast domain.

The transit gateway * attachment must be in the available state before you can add a resource. Use DescribeTransitGatewayAttachments * to see the state of the attachment.

See Also:

AWS * API Reference

*/ virtual Model::AssociateTransitGatewayMulticastDomainOutcome AssociateTransitGatewayMulticastDomain(const Model::AssociateTransitGatewayMulticastDomainRequest& request) const; /** * A Callable wrapper for AssociateTransitGatewayMulticastDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateTransitGatewayMulticastDomainOutcomeCallable AssociateTransitGatewayMulticastDomainCallable(const AssociateTransitGatewayMulticastDomainRequestT& request) const { return SubmitCallable(&EC2Client::AssociateTransitGatewayMulticastDomain, request); } /** * An Async wrapper for AssociateTransitGatewayMulticastDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateTransitGatewayMulticastDomainAsync(const AssociateTransitGatewayMulticastDomainRequestT& request, const AssociateTransitGatewayMulticastDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateTransitGatewayMulticastDomain, request, handler, context); } /** *

Associates the specified transit gateway attachment with a transit gateway * policy table.

See Also:

AWS * API Reference

*/ virtual Model::AssociateTransitGatewayPolicyTableOutcome AssociateTransitGatewayPolicyTable(const Model::AssociateTransitGatewayPolicyTableRequest& request) const; /** * A Callable wrapper for AssociateTransitGatewayPolicyTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateTransitGatewayPolicyTableOutcomeCallable AssociateTransitGatewayPolicyTableCallable(const AssociateTransitGatewayPolicyTableRequestT& request) const { return SubmitCallable(&EC2Client::AssociateTransitGatewayPolicyTable, request); } /** * An Async wrapper for AssociateTransitGatewayPolicyTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateTransitGatewayPolicyTableAsync(const AssociateTransitGatewayPolicyTableRequestT& request, const AssociateTransitGatewayPolicyTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateTransitGatewayPolicyTable, request, handler, context); } /** *

Associates the specified attachment with the specified transit gateway route * table. You can associate only one route table with an attachment.

See * Also:

AWS * API Reference

*/ virtual Model::AssociateTransitGatewayRouteTableOutcome AssociateTransitGatewayRouteTable(const Model::AssociateTransitGatewayRouteTableRequest& request) const; /** * A Callable wrapper for AssociateTransitGatewayRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateTransitGatewayRouteTableOutcomeCallable AssociateTransitGatewayRouteTableCallable(const AssociateTransitGatewayRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::AssociateTransitGatewayRouteTable, request); } /** * An Async wrapper for AssociateTransitGatewayRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateTransitGatewayRouteTableAsync(const AssociateTransitGatewayRouteTableRequestT& request, const AssociateTransitGatewayRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateTransitGatewayRouteTable, request, handler, context); } /** *

This API action is currently in limited preview only. If you * are interested in using this feature, contact your account manager.

*

Associates a branch network interface with a trunk network interface.

*

Before you create the association, run the create-network-interface * command and set --interface-type to trunk. You must * also create a network interface for each branch network interface that you want * to associate with the trunk network interface.

See Also:

AWS * API Reference

*/ virtual Model::AssociateTrunkInterfaceOutcome AssociateTrunkInterface(const Model::AssociateTrunkInterfaceRequest& request) const; /** * A Callable wrapper for AssociateTrunkInterface that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateTrunkInterfaceOutcomeCallable AssociateTrunkInterfaceCallable(const AssociateTrunkInterfaceRequestT& request) const { return SubmitCallable(&EC2Client::AssociateTrunkInterface, request); } /** * An Async wrapper for AssociateTrunkInterface that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateTrunkInterfaceAsync(const AssociateTrunkInterfaceRequestT& request, const AssociateTrunkInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateTrunkInterface, request, handler, context); } /** *

Associates a CIDR block with your VPC. You can associate a secondary IPv4 * CIDR block, an Amazon-provided IPv6 CIDR block, or an IPv6 CIDR block from an * IPv6 address pool that you provisioned through bring your own IP addresses (BYOIP). * The IPv6 CIDR block size is fixed at /56.

You must specify one of the * following in the request: an IPv4 CIDR block, an IPv6 pool, or an * Amazon-provided IPv6 CIDR block.

For more information about associating * CIDR blocks with your VPC and applicable restrictions, see IP * addressing for your VPCs and subnets in the Amazon VPC User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::AssociateVpcCidrBlockOutcome AssociateVpcCidrBlock(const Model::AssociateVpcCidrBlockRequest& request) const; /** * A Callable wrapper for AssociateVpcCidrBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateVpcCidrBlockOutcomeCallable AssociateVpcCidrBlockCallable(const AssociateVpcCidrBlockRequestT& request) const { return SubmitCallable(&EC2Client::AssociateVpcCidrBlock, request); } /** * An Async wrapper for AssociateVpcCidrBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateVpcCidrBlockAsync(const AssociateVpcCidrBlockRequestT& request, const AssociateVpcCidrBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AssociateVpcCidrBlock, request, handler, context); } /** *

This action is deprecated.

Links an EC2-Classic * instance to a ClassicLink-enabled VPC through one or more of the VPC security * groups. You cannot link an EC2-Classic instance to more than one VPC at a time. * You can only link an instance that's in the running state. An * instance is automatically unlinked from a VPC when it's stopped - you can link * it to the VPC again when you restart it.

After you've linked an instance, * you cannot change the VPC security groups that are associated with it. To change * the security groups, you must first unlink the instance, and then link it * again.

Linking your instance to a VPC is sometimes referred to as * attaching your instance.

See Also:

AWS * API Reference

*/ virtual Model::AttachClassicLinkVpcOutcome AttachClassicLinkVpc(const Model::AttachClassicLinkVpcRequest& request) const; /** * A Callable wrapper for AttachClassicLinkVpc that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachClassicLinkVpcOutcomeCallable AttachClassicLinkVpcCallable(const AttachClassicLinkVpcRequestT& request) const { return SubmitCallable(&EC2Client::AttachClassicLinkVpc, request); } /** * An Async wrapper for AttachClassicLinkVpc that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachClassicLinkVpcAsync(const AttachClassicLinkVpcRequestT& request, const AttachClassicLinkVpcResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AttachClassicLinkVpc, request, handler, context); } /** *

Attaches an internet gateway or a virtual private gateway to a VPC, enabling * connectivity between the internet and the VPC. For more information, see Internet * gateways in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::AttachInternetGatewayOutcome AttachInternetGateway(const Model::AttachInternetGatewayRequest& request) const; /** * A Callable wrapper for AttachInternetGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachInternetGatewayOutcomeCallable AttachInternetGatewayCallable(const AttachInternetGatewayRequestT& request) const { return SubmitCallable(&EC2Client::AttachInternetGateway, request); } /** * An Async wrapper for AttachInternetGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachInternetGatewayAsync(const AttachInternetGatewayRequestT& request, const AttachInternetGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AttachInternetGateway, request, handler, context); } /** *

Attaches a network interface to an instance.

See Also:

AWS * API Reference

*/ virtual Model::AttachNetworkInterfaceOutcome AttachNetworkInterface(const Model::AttachNetworkInterfaceRequest& request) const; /** * A Callable wrapper for AttachNetworkInterface that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachNetworkInterfaceOutcomeCallable AttachNetworkInterfaceCallable(const AttachNetworkInterfaceRequestT& request) const { return SubmitCallable(&EC2Client::AttachNetworkInterface, request); } /** * An Async wrapper for AttachNetworkInterface that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachNetworkInterfaceAsync(const AttachNetworkInterfaceRequestT& request, const AttachNetworkInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AttachNetworkInterface, request, handler, context); } /** *

Attaches the specified Amazon Web Services Verified Access trust provider to * the specified Amazon Web Services Verified Access instance.

See * Also:

AWS * API Reference

*/ virtual Model::AttachVerifiedAccessTrustProviderOutcome AttachVerifiedAccessTrustProvider(const Model::AttachVerifiedAccessTrustProviderRequest& request) const; /** * A Callable wrapper for AttachVerifiedAccessTrustProvider that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachVerifiedAccessTrustProviderOutcomeCallable AttachVerifiedAccessTrustProviderCallable(const AttachVerifiedAccessTrustProviderRequestT& request) const { return SubmitCallable(&EC2Client::AttachVerifiedAccessTrustProvider, request); } /** * An Async wrapper for AttachVerifiedAccessTrustProvider that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachVerifiedAccessTrustProviderAsync(const AttachVerifiedAccessTrustProviderRequestT& request, const AttachVerifiedAccessTrustProviderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AttachVerifiedAccessTrustProvider, request, handler, context); } /** *

Attaches an EBS volume to a running or stopped instance and exposes it to the * instance with the specified device name.

Encrypted EBS volumes must be * attached to instances that support Amazon EBS encryption. For more information, * see Amazon * EBS encryption in the Amazon Elastic Compute Cloud User Guide.

*

After you attach an EBS volume, you must make it available. For more * information, see Make * an EBS volume available for use.

If a volume has an Amazon Web * Services Marketplace product code:

  • The volume can be attached * only to a stopped instance.

  • Amazon Web Services Marketplace * product codes are copied from the volume to the instance.

  • You * must be subscribed to the product.

  • The instance type and * operating system of the instance must support the product. For example, you * can't detach a volume from a Windows instance and attach it to a Linux * instance.

For more information, see Attach * an Amazon EBS volume to an instance in the Amazon Elastic Compute Cloud * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::AttachVolumeOutcome AttachVolume(const Model::AttachVolumeRequest& request) const; /** * A Callable wrapper for AttachVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachVolumeOutcomeCallable AttachVolumeCallable(const AttachVolumeRequestT& request) const { return SubmitCallable(&EC2Client::AttachVolume, request); } /** * An Async wrapper for AttachVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachVolumeAsync(const AttachVolumeRequestT& request, const AttachVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AttachVolume, request, handler, context); } /** *

Attaches a virtual private gateway to a VPC. You can attach one virtual * private gateway to one VPC at a time.

For more information, see Amazon Web * Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::AttachVpnGatewayOutcome AttachVpnGateway(const Model::AttachVpnGatewayRequest& request) const; /** * A Callable wrapper for AttachVpnGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachVpnGatewayOutcomeCallable AttachVpnGatewayCallable(const AttachVpnGatewayRequestT& request) const { return SubmitCallable(&EC2Client::AttachVpnGateway, request); } /** * An Async wrapper for AttachVpnGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachVpnGatewayAsync(const AttachVpnGatewayRequestT& request, const AttachVpnGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AttachVpnGateway, request, handler, context); } /** *

Adds an ingress authorization rule to a Client VPN endpoint. Ingress * authorization rules act as firewall rules that grant access to networks. You * must configure ingress authorization rules to enable clients to access resources * in Amazon Web Services or on-premises networks.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeClientVpnIngressOutcome AuthorizeClientVpnIngress(const Model::AuthorizeClientVpnIngressRequest& request) const; /** * A Callable wrapper for AuthorizeClientVpnIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeClientVpnIngressOutcomeCallable AuthorizeClientVpnIngressCallable(const AuthorizeClientVpnIngressRequestT& request) const { return SubmitCallable(&EC2Client::AuthorizeClientVpnIngress, request); } /** * An Async wrapper for AuthorizeClientVpnIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeClientVpnIngressAsync(const AuthorizeClientVpnIngressRequestT& request, const AuthorizeClientVpnIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AuthorizeClientVpnIngress, request, handler, context); } /** *

Adds the specified outbound (egress) rules to a security group for use with a * VPC.

An outbound rule permits instances to send traffic to the specified * IPv4 or IPv6 CIDR address ranges, or to the instances that are associated with * the specified source security groups. When specifying an outbound rule for your * security group in a VPC, the IpPermissions must include a * destination for the traffic.

You specify a protocol for each rule (for * example, TCP). For the TCP and UDP protocols, you must also specify the * destination port or port range. For the ICMP protocol, you must also specify the * ICMP type and code. You can use -1 for the type or code to mean all types or all * codes.

Rule changes are propagated to affected instances as quickly as * possible. However, a small delay might occur.

For information about VPC * security group quotas, see Amazon * VPC quotas.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeSecurityGroupEgressOutcome AuthorizeSecurityGroupEgress(const Model::AuthorizeSecurityGroupEgressRequest& request) const; /** * A Callable wrapper for AuthorizeSecurityGroupEgress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeSecurityGroupEgressOutcomeCallable AuthorizeSecurityGroupEgressCallable(const AuthorizeSecurityGroupEgressRequestT& request) const { return SubmitCallable(&EC2Client::AuthorizeSecurityGroupEgress, request); } /** * An Async wrapper for AuthorizeSecurityGroupEgress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeSecurityGroupEgressAsync(const AuthorizeSecurityGroupEgressRequestT& request, const AuthorizeSecurityGroupEgressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AuthorizeSecurityGroupEgress, request, handler, context); } /** *

Adds the specified inbound (ingress) rules to a security group.

An * inbound rule permits instances to receive traffic from the specified IPv4 or * IPv6 CIDR address range, or from the instances that are associated with the * specified destination security groups. When specifying an inbound rule for your * security group in a VPC, the IpPermissions must include a source * for the traffic.

You specify a protocol for each rule (for example, TCP). * For TCP and UDP, you must also specify the destination port or port range. For * ICMP/ICMPv6, you must also specify the ICMP/ICMPv6 type and code. You can use -1 * to mean all types or all codes.

Rule changes are propagated to instances * within the security group as quickly as possible. However, a small delay might * occur.

For more information about VPC security group quotas, see Amazon * VPC quotas.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeSecurityGroupIngressOutcome AuthorizeSecurityGroupIngress(const Model::AuthorizeSecurityGroupIngressRequest& request) const; /** * A Callable wrapper for AuthorizeSecurityGroupIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeSecurityGroupIngressOutcomeCallable AuthorizeSecurityGroupIngressCallable(const AuthorizeSecurityGroupIngressRequestT& request) const { return SubmitCallable(&EC2Client::AuthorizeSecurityGroupIngress, request); } /** * An Async wrapper for AuthorizeSecurityGroupIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeSecurityGroupIngressAsync(const AuthorizeSecurityGroupIngressRequestT& request, const AuthorizeSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::AuthorizeSecurityGroupIngress, request, handler, context); } /** *

Bundles an Amazon instance store-backed Windows instance.

During * bundling, only the root device volume (C:\) is bundled. Data on other instance * store volumes is not preserved.

This action is not applicable for * Linux/Unix instances or Windows instances that are backed by Amazon EBS.

*

See Also:

AWS * API Reference

*/ virtual Model::BundleInstanceOutcome BundleInstance(const Model::BundleInstanceRequest& request) const; /** * A Callable wrapper for BundleInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BundleInstanceOutcomeCallable BundleInstanceCallable(const BundleInstanceRequestT& request) const { return SubmitCallable(&EC2Client::BundleInstance, request); } /** * An Async wrapper for BundleInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BundleInstanceAsync(const BundleInstanceRequestT& request, const BundleInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::BundleInstance, request, handler, context); } /** *

Cancels a bundling operation for an instance store-backed Windows * instance.

See Also:

AWS * API Reference

*/ virtual Model::CancelBundleTaskOutcome CancelBundleTask(const Model::CancelBundleTaskRequest& request) const; /** * A Callable wrapper for CancelBundleTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelBundleTaskOutcomeCallable CancelBundleTaskCallable(const CancelBundleTaskRequestT& request) const { return SubmitCallable(&EC2Client::CancelBundleTask, request); } /** * An Async wrapper for CancelBundleTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelBundleTaskAsync(const CancelBundleTaskRequestT& request, const CancelBundleTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelBundleTask, request, handler, context); } /** *

Cancels the specified Capacity Reservation, releases the reserved capacity, * and changes the Capacity Reservation's state to cancelled.

*

Instances running in the reserved capacity continue running until you stop * them. Stopped instances that target the Capacity Reservation can no longer * launch. Modify these instances to either target a different Capacity * Reservation, launch On-Demand Instance capacity, or run in any open Capacity * Reservation that has matching attributes and sufficient capacity.

See * Also:

AWS * API Reference

*/ virtual Model::CancelCapacityReservationOutcome CancelCapacityReservation(const Model::CancelCapacityReservationRequest& request) const; /** * A Callable wrapper for CancelCapacityReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelCapacityReservationOutcomeCallable CancelCapacityReservationCallable(const CancelCapacityReservationRequestT& request) const { return SubmitCallable(&EC2Client::CancelCapacityReservation, request); } /** * An Async wrapper for CancelCapacityReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelCapacityReservationAsync(const CancelCapacityReservationRequestT& request, const CancelCapacityReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelCapacityReservation, request, handler, context); } /** *

Cancels one or more Capacity Reservation Fleets. When you cancel a Capacity * Reservation Fleet, the following happens:

  • The Capacity * Reservation Fleet's status changes to cancelled.

  • *

    The individual Capacity Reservations in the Fleet are cancelled. Instances * running in the Capacity Reservations at the time of cancelling the Fleet * continue to run in shared capacity.

  • The Fleet stops creating * new Capacity Reservations.

See Also:

AWS * API Reference

*/ virtual Model::CancelCapacityReservationFleetsOutcome CancelCapacityReservationFleets(const Model::CancelCapacityReservationFleetsRequest& request) const; /** * A Callable wrapper for CancelCapacityReservationFleets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelCapacityReservationFleetsOutcomeCallable CancelCapacityReservationFleetsCallable(const CancelCapacityReservationFleetsRequestT& request) const { return SubmitCallable(&EC2Client::CancelCapacityReservationFleets, request); } /** * An Async wrapper for CancelCapacityReservationFleets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelCapacityReservationFleetsAsync(const CancelCapacityReservationFleetsRequestT& request, const CancelCapacityReservationFleetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelCapacityReservationFleets, request, handler, context); } /** *

Cancels an active conversion task. The task can be the import of an instance * or volume. The action removes all artifacts of the conversion, including a * partially uploaded volume or instance. If the conversion is complete or is in * the process of transferring the final disk image, the command fails and returns * an exception.

For more information, see Importing * a Virtual Machine Using the Amazon EC2 CLI.

See Also:

AWS * API Reference

*/ virtual Model::CancelConversionTaskOutcome CancelConversionTask(const Model::CancelConversionTaskRequest& request) const; /** * A Callable wrapper for CancelConversionTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelConversionTaskOutcomeCallable CancelConversionTaskCallable(const CancelConversionTaskRequestT& request) const { return SubmitCallable(&EC2Client::CancelConversionTask, request); } /** * An Async wrapper for CancelConversionTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelConversionTaskAsync(const CancelConversionTaskRequestT& request, const CancelConversionTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelConversionTask, request, handler, context); } /** *

Cancels an active export task. The request removes all artifacts of the * export, including any partially-created Amazon S3 objects. If the export task is * complete or is in the process of transferring the final disk image, the command * fails and returns an error.

See Also:

AWS * API Reference

*/ virtual Model::CancelExportTaskOutcome CancelExportTask(const Model::CancelExportTaskRequest& request) const; /** * A Callable wrapper for CancelExportTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelExportTaskOutcomeCallable CancelExportTaskCallable(const CancelExportTaskRequestT& request) const { return SubmitCallable(&EC2Client::CancelExportTask, request); } /** * An Async wrapper for CancelExportTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelExportTaskAsync(const CancelExportTaskRequestT& request, const CancelExportTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelExportTask, request, handler, context); } /** *

Removes your Amazon Web Services account from the launch permissions for the * specified AMI. For more information, see * Cancel having an AMI shared with your Amazon Web Services account in the * Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CancelImageLaunchPermissionOutcome CancelImageLaunchPermission(const Model::CancelImageLaunchPermissionRequest& request) const; /** * A Callable wrapper for CancelImageLaunchPermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelImageLaunchPermissionOutcomeCallable CancelImageLaunchPermissionCallable(const CancelImageLaunchPermissionRequestT& request) const { return SubmitCallable(&EC2Client::CancelImageLaunchPermission, request); } /** * An Async wrapper for CancelImageLaunchPermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelImageLaunchPermissionAsync(const CancelImageLaunchPermissionRequestT& request, const CancelImageLaunchPermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelImageLaunchPermission, request, handler, context); } /** *

Cancels an in-process import virtual machine or import snapshot * task.

See Also:

AWS * API Reference

*/ virtual Model::CancelImportTaskOutcome CancelImportTask(const Model::CancelImportTaskRequest& request) const; /** * A Callable wrapper for CancelImportTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelImportTaskOutcomeCallable CancelImportTaskCallable(const CancelImportTaskRequestT& request) const { return SubmitCallable(&EC2Client::CancelImportTask, request); } /** * An Async wrapper for CancelImportTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelImportTaskAsync(const CancelImportTaskRequestT& request, const CancelImportTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelImportTask, request, handler, context); } /** *

Cancels the specified Reserved Instance listing in the Reserved Instance * Marketplace.

For more information, see Reserved * Instance Marketplace in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CancelReservedInstancesListingOutcome CancelReservedInstancesListing(const Model::CancelReservedInstancesListingRequest& request) const; /** * A Callable wrapper for CancelReservedInstancesListing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelReservedInstancesListingOutcomeCallable CancelReservedInstancesListingCallable(const CancelReservedInstancesListingRequestT& request) const { return SubmitCallable(&EC2Client::CancelReservedInstancesListing, request); } /** * An Async wrapper for CancelReservedInstancesListing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelReservedInstancesListingAsync(const CancelReservedInstancesListingRequestT& request, const CancelReservedInstancesListingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelReservedInstancesListing, request, handler, context); } /** *

Cancels the specified Spot Fleet requests.

After you cancel a Spot * Fleet request, the Spot Fleet launches no new instances.

You must also * specify whether a canceled Spot Fleet request should terminate its instances. If * you choose to terminate the instances, the Spot Fleet request enters the * cancelled_terminating state. Otherwise, the Spot Fleet request * enters the cancelled_running state and the instances continue to * run until they are interrupted or you terminate them manually.

See * Also:

AWS * API Reference

*/ virtual Model::CancelSpotFleetRequestsOutcome CancelSpotFleetRequests(const Model::CancelSpotFleetRequestsRequest& request) const; /** * A Callable wrapper for CancelSpotFleetRequests that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelSpotFleetRequestsOutcomeCallable CancelSpotFleetRequestsCallable(const CancelSpotFleetRequestsRequestT& request) const { return SubmitCallable(&EC2Client::CancelSpotFleetRequests, request); } /** * An Async wrapper for CancelSpotFleetRequests that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelSpotFleetRequestsAsync(const CancelSpotFleetRequestsRequestT& request, const CancelSpotFleetRequestsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelSpotFleetRequests, request, handler, context); } /** *

Cancels one or more Spot Instance requests.

Canceling a * Spot Instance request does not terminate running Spot Instances associated with * the request.

See Also:

AWS * API Reference

*/ virtual Model::CancelSpotInstanceRequestsOutcome CancelSpotInstanceRequests(const Model::CancelSpotInstanceRequestsRequest& request) const; /** * A Callable wrapper for CancelSpotInstanceRequests that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelSpotInstanceRequestsOutcomeCallable CancelSpotInstanceRequestsCallable(const CancelSpotInstanceRequestsRequestT& request) const { return SubmitCallable(&EC2Client::CancelSpotInstanceRequests, request); } /** * An Async wrapper for CancelSpotInstanceRequests that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelSpotInstanceRequestsAsync(const CancelSpotInstanceRequestsRequestT& request, const CancelSpotInstanceRequestsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CancelSpotInstanceRequests, request, handler, context); } /** *

Determines whether a product code is associated with an instance. This action * can only be used by the owner of the product code. It is useful when a product * code owner must verify whether another user's instance is eligible for * support.

See Also:

AWS * API Reference

*/ virtual Model::ConfirmProductInstanceOutcome ConfirmProductInstance(const Model::ConfirmProductInstanceRequest& request) const; /** * A Callable wrapper for ConfirmProductInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ConfirmProductInstanceOutcomeCallable ConfirmProductInstanceCallable(const ConfirmProductInstanceRequestT& request) const { return SubmitCallable(&EC2Client::ConfirmProductInstance, request); } /** * An Async wrapper for ConfirmProductInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ConfirmProductInstanceAsync(const ConfirmProductInstanceRequestT& request, const ConfirmProductInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ConfirmProductInstance, request, handler, context); } /** *

Copies the specified Amazon FPGA Image (AFI) to the current * Region.

See Also:

AWS * API Reference

*/ virtual Model::CopyFpgaImageOutcome CopyFpgaImage(const Model::CopyFpgaImageRequest& request) const; /** * A Callable wrapper for CopyFpgaImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyFpgaImageOutcomeCallable CopyFpgaImageCallable(const CopyFpgaImageRequestT& request) const { return SubmitCallable(&EC2Client::CopyFpgaImage, request); } /** * An Async wrapper for CopyFpgaImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyFpgaImageAsync(const CopyFpgaImageRequestT& request, const CopyFpgaImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CopyFpgaImage, request, handler, context); } /** *

Initiates the copy of an AMI. You can copy an AMI from one Region to another, * or from a Region to an Outpost. You can't copy an AMI from an Outpost to a * Region, from one Outpost to another, or within the same Outpost. To copy an AMI * to another partition, see CreateStoreImageTask.

*

To copy an AMI from one Region to another, specify the source Region using * the SourceRegion parameter, and specify the destination Region using its * endpoint. Copies of encrypted backing snapshots for the AMI are encrypted. * Copies of unencrypted backing snapshots remain unencrypted, unless you set * Encrypted during the copy operation. You cannot create an * unencrypted copy of an encrypted backing snapshot.

To copy an AMI from a * Region to an Outpost, specify the source Region using the SourceRegion * parameter, and specify the ARN of the destination Outpost using * DestinationOutpostArn. Backing snapshots copied to an Outpost are * encrypted by default using the default encryption key for the Region, or a * different key that you specify in the request using KmsKeyId. Outposts do * not support unencrypted snapshots. For more information, * Amazon EBS local snapshots on Outposts in the Amazon EC2 User * Guide.

For more information about the prerequisites and limits when * copying an AMI, see Copy * an AMI in the Amazon EC2 User Guide.

See Also:

AWS API * Reference

*/ virtual Model::CopyImageOutcome CopyImage(const Model::CopyImageRequest& request) const; /** * A Callable wrapper for CopyImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyImageOutcomeCallable CopyImageCallable(const CopyImageRequestT& request) const { return SubmitCallable(&EC2Client::CopyImage, request); } /** * An Async wrapper for CopyImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyImageAsync(const CopyImageRequestT& request, const CopyImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CopyImage, request, handler, context); } /** *

Copies a point-in-time snapshot of an EBS volume and stores it in Amazon S3. * You can copy a snapshot within the same Region, from one Region to another, or * from a Region to an Outpost. You can't copy a snapshot from an Outpost to a * Region, from one Outpost to another, or within the same Outpost.

You can * use the snapshot to create EBS volumes or Amazon Machine Images (AMIs).

*

When copying snapshots to a Region, copies of encrypted EBS snapshots remain * encrypted. Copies of unencrypted snapshots remain unencrypted, unless you enable * encryption for the snapshot copy operation. By default, encrypted snapshot * copies use the default Key Management Service (KMS) KMS key; however, you can * specify a different KMS key. To copy an encrypted snapshot that has been shared * from another account, you must have permissions for the KMS key used to encrypt * the snapshot.

Snapshots copied to an Outpost are encrypted by default * using the default encryption key for the Region, or a different key that you * specify in the request using KmsKeyId. Outposts do not support * unencrypted snapshots. For more information, * Amazon EBS local snapshots on Outposts in the Amazon Elastic Compute * Cloud User Guide.

Snapshots created by copying another snapshot have * an arbitrary volume ID that should not be used for any purpose.

For more * information, see Copy * an Amazon EBS snapshot in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CopySnapshotOutcome CopySnapshot(const Model::CopySnapshotRequest& request) const; /** * A Callable wrapper for CopySnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopySnapshotOutcomeCallable CopySnapshotCallable(const CopySnapshotRequestT& request) const { return SubmitCallable(&EC2Client::CopySnapshot, request); } /** * An Async wrapper for CopySnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopySnapshotAsync(const CopySnapshotRequestT& request, const CopySnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CopySnapshot, request, handler, context); } /** *

Creates a new Capacity Reservation with the specified attributes.

*

Capacity Reservations enable you to reserve capacity for your Amazon EC2 * instances in a specific Availability Zone for any duration. This gives you the * flexibility to selectively add capacity reservations and still get the Regional * RI discounts for that usage. By creating Capacity Reservations, you ensure that * you always have access to Amazon EC2 capacity when you need it, for as long as * you need it. For more information, see Capacity * Reservations in the Amazon EC2 User Guide.

Your request to * create a Capacity Reservation could fail if Amazon EC2 does not have sufficient * capacity to fulfill the request. If your request fails due to Amazon EC2 * capacity constraints, either try again at a later time, try in a different * Availability Zone, or request a smaller capacity reservation. If your * application is flexible across instance types and sizes, try to create a * Capacity Reservation with different instance attributes.

Your request * could also fail if the requested quantity exceeds your On-Demand Instance limit * for the selected instance type. If your request fails due to limit constraints, * increase your On-Demand Instance limit for the required instance type and try * again. For more information about increasing your instance limits, see Amazon * EC2 Service Quotas in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateCapacityReservationOutcome CreateCapacityReservation(const Model::CreateCapacityReservationRequest& request) const; /** * A Callable wrapper for CreateCapacityReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCapacityReservationOutcomeCallable CreateCapacityReservationCallable(const CreateCapacityReservationRequestT& request) const { return SubmitCallable(&EC2Client::CreateCapacityReservation, request); } /** * An Async wrapper for CreateCapacityReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCapacityReservationAsync(const CreateCapacityReservationRequestT& request, const CreateCapacityReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateCapacityReservation, request, handler, context); } /** *

Creates a Capacity Reservation Fleet. For more information, see Create * a Capacity Reservation Fleet in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateCapacityReservationFleetOutcome CreateCapacityReservationFleet(const Model::CreateCapacityReservationFleetRequest& request) const; /** * A Callable wrapper for CreateCapacityReservationFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCapacityReservationFleetOutcomeCallable CreateCapacityReservationFleetCallable(const CreateCapacityReservationFleetRequestT& request) const { return SubmitCallable(&EC2Client::CreateCapacityReservationFleet, request); } /** * An Async wrapper for CreateCapacityReservationFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCapacityReservationFleetAsync(const CreateCapacityReservationFleetRequestT& request, const CreateCapacityReservationFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateCapacityReservationFleet, request, handler, context); } /** *

Creates a carrier gateway. For more information about carrier gateways, see * Carrier * gateways in the Amazon Web Services Wavelength Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateCarrierGatewayOutcome CreateCarrierGateway(const Model::CreateCarrierGatewayRequest& request) const; /** * A Callable wrapper for CreateCarrierGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCarrierGatewayOutcomeCallable CreateCarrierGatewayCallable(const CreateCarrierGatewayRequestT& request) const { return SubmitCallable(&EC2Client::CreateCarrierGateway, request); } /** * An Async wrapper for CreateCarrierGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCarrierGatewayAsync(const CreateCarrierGatewayRequestT& request, const CreateCarrierGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateCarrierGateway, request, handler, context); } /** *

Creates a Client VPN endpoint. A Client VPN endpoint is the resource you * create and configure to enable and manage client VPN sessions. It is the * destination endpoint at which all client VPN sessions are * terminated.

See Also:

AWS * API Reference

*/ virtual Model::CreateClientVpnEndpointOutcome CreateClientVpnEndpoint(const Model::CreateClientVpnEndpointRequest& request) const; /** * A Callable wrapper for CreateClientVpnEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateClientVpnEndpointOutcomeCallable CreateClientVpnEndpointCallable(const CreateClientVpnEndpointRequestT& request) const { return SubmitCallable(&EC2Client::CreateClientVpnEndpoint, request); } /** * An Async wrapper for CreateClientVpnEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateClientVpnEndpointAsync(const CreateClientVpnEndpointRequestT& request, const CreateClientVpnEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateClientVpnEndpoint, request, handler, context); } /** *

Adds a route to a network to a Client VPN endpoint. Each Client VPN endpoint * has a route table that describes the available destination network routes. Each * route in the route table specifies the path for traffic to specific resources or * networks.

See Also:

AWS * API Reference

*/ virtual Model::CreateClientVpnRouteOutcome CreateClientVpnRoute(const Model::CreateClientVpnRouteRequest& request) const; /** * A Callable wrapper for CreateClientVpnRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateClientVpnRouteOutcomeCallable CreateClientVpnRouteCallable(const CreateClientVpnRouteRequestT& request) const { return SubmitCallable(&EC2Client::CreateClientVpnRoute, request); } /** * An Async wrapper for CreateClientVpnRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateClientVpnRouteAsync(const CreateClientVpnRouteRequestT& request, const CreateClientVpnRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateClientVpnRoute, request, handler, context); } /** *

Creates a range of customer-owned IP addresses.

See Also:

* AWS * API Reference

*/ virtual Model::CreateCoipCidrOutcome CreateCoipCidr(const Model::CreateCoipCidrRequest& request) const; /** * A Callable wrapper for CreateCoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCoipCidrOutcomeCallable CreateCoipCidrCallable(const CreateCoipCidrRequestT& request) const { return SubmitCallable(&EC2Client::CreateCoipCidr, request); } /** * An Async wrapper for CreateCoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCoipCidrAsync(const CreateCoipCidrRequestT& request, const CreateCoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateCoipCidr, request, handler, context); } /** *

Creates a pool of customer-owned IP (CoIP) addresses.

See * Also:

AWS * API Reference

*/ virtual Model::CreateCoipPoolOutcome CreateCoipPool(const Model::CreateCoipPoolRequest& request) const; /** * A Callable wrapper for CreateCoipPool that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCoipPoolOutcomeCallable CreateCoipPoolCallable(const CreateCoipPoolRequestT& request) const { return SubmitCallable(&EC2Client::CreateCoipPool, request); } /** * An Async wrapper for CreateCoipPool that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCoipPoolAsync(const CreateCoipPoolRequestT& request, const CreateCoipPoolResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateCoipPool, request, handler, context); } /** *

Provides information to Amazon Web Services about your customer gateway * device. The customer gateway device is the appliance at your end of the VPN * connection. You must provide the IP address of the customer gateway device’s * external interface. The IP address must be static and can be behind a device * performing network address translation (NAT).

For devices that use Border * Gateway Protocol (BGP), you can also provide the device's BGP Autonomous System * Number (ASN). You can use an existing ASN assigned to your network. If you don't * have an ASN already, you can use a private ASN. For more information, see Customer * gateway options for your Site-to-Site VPN connection in the Amazon Web * Services Site-to-Site VPN User Guide.

To create more than one * customer gateway with the same VPN type, IP address, and BGP ASN, specify a * unique device name for each customer gateway. An identical request returns * information about the existing customer gateway; it doesn't create a new * customer gateway.

See Also:

AWS * API Reference

*/ virtual Model::CreateCustomerGatewayOutcome CreateCustomerGateway(const Model::CreateCustomerGatewayRequest& request) const; /** * A Callable wrapper for CreateCustomerGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCustomerGatewayOutcomeCallable CreateCustomerGatewayCallable(const CreateCustomerGatewayRequestT& request) const { return SubmitCallable(&EC2Client::CreateCustomerGateway, request); } /** * An Async wrapper for CreateCustomerGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCustomerGatewayAsync(const CreateCustomerGatewayRequestT& request, const CreateCustomerGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateCustomerGateway, request, handler, context); } /** *

Creates a default subnet with a size /20 IPv4 CIDR block in the * specified Availability Zone in your default VPC. You can have only one default * subnet per Availability Zone. For more information, see Create * a default subnet in the Amazon VPC User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateDefaultSubnetOutcome CreateDefaultSubnet(const Model::CreateDefaultSubnetRequest& request) const; /** * A Callable wrapper for CreateDefaultSubnet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDefaultSubnetOutcomeCallable CreateDefaultSubnetCallable(const CreateDefaultSubnetRequestT& request) const { return SubmitCallable(&EC2Client::CreateDefaultSubnet, request); } /** * An Async wrapper for CreateDefaultSubnet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDefaultSubnetAsync(const CreateDefaultSubnetRequestT& request, const CreateDefaultSubnetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateDefaultSubnet, request, handler, context); } /** *

Creates a default VPC with a size /16 IPv4 CIDR block and a * default subnet in each Availability Zone. For more information about the * components of a default VPC, see Default * VPCs in the Amazon VPC User Guide. You cannot specify the components * of the default VPC yourself.

If you deleted your previous default VPC, * you can create a default VPC. You cannot have more than one default VPC per * Region.

See Also:

AWS * API Reference

*/ virtual Model::CreateDefaultVpcOutcome CreateDefaultVpc(const Model::CreateDefaultVpcRequest& request) const; /** * A Callable wrapper for CreateDefaultVpc that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDefaultVpcOutcomeCallable CreateDefaultVpcCallable(const CreateDefaultVpcRequestT& request) const { return SubmitCallable(&EC2Client::CreateDefaultVpc, request); } /** * An Async wrapper for CreateDefaultVpc that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDefaultVpcAsync(const CreateDefaultVpcRequestT& request, const CreateDefaultVpcResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateDefaultVpc, request, handler, context); } /** *

Creates a set of DHCP options for your VPC. After creating the set, you must * associate it with the VPC, causing all existing and new instances that you * launch in the VPC to use this set of DHCP options. The following are the * individual DHCP options you can specify. For more information about the options, * see RFC 2132.

  • *

    domain-name-servers - The IP addresses of up to four domain * name servers, or AmazonProvidedDNS. The default DHCP option set specifies * AmazonProvidedDNS. If specifying more than one domain name server, specify the * IP addresses in a single parameter, separated by commas. To have your instance * receive a custom DNS hostname as specified in domain-name, you must * set domain-name-servers to a custom DNS server.

  • * domain-name - If you're using AmazonProvidedDNS in * us-east-1, specify ec2.internal. If you're using * AmazonProvidedDNS in another Region, specify * region.compute.internal (for example, * ap-northeast-1.compute.internal). Otherwise, specify a domain name * (for example, ExampleCompany.com). This value is used to complete * unqualified DNS hostnames. Important: Some Linux operating systems accept * multiple domain names separated by spaces. However, Windows and other Linux * operating systems treat the value as a single domain, which results in * unexpected behavior. If your DHCP options set is associated with a VPC that has * instances with multiple operating systems, specify only one domain name.

    *

  • ntp-servers - The IP addresses of up to four Network * Time Protocol (NTP) servers.

  • * netbios-name-servers - The IP addresses of up to four NetBIOS name * servers.

  • netbios-node-type - The NetBIOS node * type (1, 2, 4, or 8). We recommend that you specify 2 (broadcast and multicast * are not currently supported). For more information about these node types, see * RFC 2132.

*

Your VPC automatically starts out with a set of DHCP options that includes * only a DNS server that we provide (AmazonProvidedDNS). If you create a set of * options, and if your VPC has an internet gateway, make sure to set the * domain-name-servers option either to AmazonProvidedDNS * or to a domain name server of your choice. For more information, see DHCP * options sets in the Amazon VPC User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::CreateDhcpOptionsOutcome CreateDhcpOptions(const Model::CreateDhcpOptionsRequest& request) const; /** * A Callable wrapper for CreateDhcpOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDhcpOptionsOutcomeCallable CreateDhcpOptionsCallable(const CreateDhcpOptionsRequestT& request) const { return SubmitCallable(&EC2Client::CreateDhcpOptions, request); } /** * An Async wrapper for CreateDhcpOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDhcpOptionsAsync(const CreateDhcpOptionsRequestT& request, const CreateDhcpOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateDhcpOptions, request, handler, context); } /** *

[IPv6 only] Creates an egress-only internet gateway for your VPC. An * egress-only internet gateway is used to enable outbound communication over IPv6 * from instances in your VPC to the internet, and prevents hosts outside of your * VPC from initiating an IPv6 connection with your instance.

See * Also:

AWS * API Reference

*/ virtual Model::CreateEgressOnlyInternetGatewayOutcome CreateEgressOnlyInternetGateway(const Model::CreateEgressOnlyInternetGatewayRequest& request) const; /** * A Callable wrapper for CreateEgressOnlyInternetGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEgressOnlyInternetGatewayOutcomeCallable CreateEgressOnlyInternetGatewayCallable(const CreateEgressOnlyInternetGatewayRequestT& request) const { return SubmitCallable(&EC2Client::CreateEgressOnlyInternetGateway, request); } /** * An Async wrapper for CreateEgressOnlyInternetGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEgressOnlyInternetGatewayAsync(const CreateEgressOnlyInternetGatewayRequestT& request, const CreateEgressOnlyInternetGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateEgressOnlyInternetGateway, request, handler, context); } /** *

Creates an EC2 Fleet that contains the configuration information for * On-Demand Instances and Spot Instances. Instances are launched immediately if * there is available capacity.

A single EC2 Fleet can include multiple * launch specifications that vary by instance type, AMI, Availability Zone, or * subnet.

For more information, see EC2 * Fleet in the Amazon EC2 User Guide.

See Also:

AWS API * Reference

*/ virtual Model::CreateFleetOutcome CreateFleet(const Model::CreateFleetRequest& request) const; /** * A Callable wrapper for CreateFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFleetOutcomeCallable CreateFleetCallable(const CreateFleetRequestT& request) const { return SubmitCallable(&EC2Client::CreateFleet, request); } /** * An Async wrapper for CreateFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFleetAsync(const CreateFleetRequestT& request, const CreateFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateFleet, request, handler, context); } /** *

Creates one or more flow logs to capture information about IP traffic for a * specific network interface, subnet, or VPC.

Flow log data for a * monitored network interface is recorded as flow log records, which are log * events consisting of fields that describe the traffic flow. For more * information, see Flow * log records in the Amazon Virtual Private Cloud User Guide.

*

When publishing to CloudWatch Logs, flow log records are published to a log * group, and each network interface has a unique log stream in the log group. When * publishing to Amazon S3, flow log records for all of the monitored network * interfaces are published to a single log file object that is stored in the * specified bucket.

For more information, see VPC Flow * Logs in the Amazon Virtual Private Cloud User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateFlowLogsOutcome CreateFlowLogs(const Model::CreateFlowLogsRequest& request) const; /** * A Callable wrapper for CreateFlowLogs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFlowLogsOutcomeCallable CreateFlowLogsCallable(const CreateFlowLogsRequestT& request) const { return SubmitCallable(&EC2Client::CreateFlowLogs, request); } /** * An Async wrapper for CreateFlowLogs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFlowLogsAsync(const CreateFlowLogsRequestT& request, const CreateFlowLogsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateFlowLogs, request, handler, context); } /** *

Creates an Amazon FPGA Image (AFI) from the specified design checkpoint * (DCP).

The create operation is asynchronous. To verify that the AFI is * ready for use, check the output logs.

An AFI contains the FPGA bitstream * that is ready to download to an FPGA. You can securely deploy an AFI on multiple * FPGA-accelerated instances. For more information, see the Amazon Web Services FPGA Hardware * Development Kit.

See Also:

AWS * API Reference

*/ virtual Model::CreateFpgaImageOutcome CreateFpgaImage(const Model::CreateFpgaImageRequest& request) const; /** * A Callable wrapper for CreateFpgaImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFpgaImageOutcomeCallable CreateFpgaImageCallable(const CreateFpgaImageRequestT& request) const { return SubmitCallable(&EC2Client::CreateFpgaImage, request); } /** * An Async wrapper for CreateFpgaImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFpgaImageAsync(const CreateFpgaImageRequestT& request, const CreateFpgaImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateFpgaImage, request, handler, context); } /** *

Creates an Amazon EBS-backed AMI from an Amazon EBS-backed instance that is * either running or stopped.

If you customized your instance with instance * store volumes or Amazon EBS volumes in addition to the root device volume, the * new AMI contains block device mapping information for those volumes. When you * launch an instance from this new AMI, the instance automatically launches with * those additional volumes.

For more information, see Create * an Amazon EBS-backed Linux AMI in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS API * Reference

*/ virtual Model::CreateImageOutcome CreateImage(const Model::CreateImageRequest& request) const; /** * A Callable wrapper for CreateImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateImageOutcomeCallable CreateImageCallable(const CreateImageRequestT& request) const { return SubmitCallable(&EC2Client::CreateImage, request); } /** * An Async wrapper for CreateImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateImageAsync(const CreateImageRequestT& request, const CreateImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateImage, request, handler, context); } /** *

Creates an EC2 Instance Connect Endpoint.

An EC2 Instance Connect * Endpoint allows you to connect to an instance, without requiring the instance to * have a public IPv4 address. For more information, see Connect * to your instances without requiring a public IPv4 address using EC2 Instance * Connect Endpoint in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateInstanceConnectEndpointOutcome CreateInstanceConnectEndpoint(const Model::CreateInstanceConnectEndpointRequest& request) const; /** * A Callable wrapper for CreateInstanceConnectEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInstanceConnectEndpointOutcomeCallable CreateInstanceConnectEndpointCallable(const CreateInstanceConnectEndpointRequestT& request) const { return SubmitCallable(&EC2Client::CreateInstanceConnectEndpoint, request); } /** * An Async wrapper for CreateInstanceConnectEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInstanceConnectEndpointAsync(const CreateInstanceConnectEndpointRequestT& request, const CreateInstanceConnectEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateInstanceConnectEndpoint, request, handler, context); } /** *

Creates an event window in which scheduled events for the associated Amazon * EC2 instances can run.

You can define either a set of time ranges or a * cron expression when creating the event window, but not both. All event window * times are in UTC.

You can create up to 200 event windows per Amazon Web * Services Region.

When you create the event window, targets (instance IDs, * Dedicated Host IDs, or tags) are not yet associated with it. To ensure that the * event window can be used, you must associate one or more targets with it by * using the AssociateInstanceEventWindow API.

Event * windows are applicable only for scheduled events that stop, reboot, or terminate * instances.

Event windows are not applicable for:

  • *

    Expedited scheduled events and network maintenance events.

  • *

    Unscheduled maintenance such as AutoRecovery and unplanned reboots.

    • *

For more information, see Define * event windows for scheduled events in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateInstanceEventWindowOutcome CreateInstanceEventWindow(const Model::CreateInstanceEventWindowRequest& request) const; /** * A Callable wrapper for CreateInstanceEventWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInstanceEventWindowOutcomeCallable CreateInstanceEventWindowCallable(const CreateInstanceEventWindowRequestT& request) const { return SubmitCallable(&EC2Client::CreateInstanceEventWindow, request); } /** * An Async wrapper for CreateInstanceEventWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInstanceEventWindowAsync(const CreateInstanceEventWindowRequestT& request, const CreateInstanceEventWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateInstanceEventWindow, request, handler, context); } /** *

Exports a running or stopped instance to an Amazon S3 bucket.

For * information about the prerequisites for your Amazon S3 bucket, supported * operating systems, image formats, and known limitations for the types of * instances you can export, see Exporting * an instance as a VM Using VM Import/Export in the VM Import/Export User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateInstanceExportTaskOutcome CreateInstanceExportTask(const Model::CreateInstanceExportTaskRequest& request) const; /** * A Callable wrapper for CreateInstanceExportTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInstanceExportTaskOutcomeCallable CreateInstanceExportTaskCallable(const CreateInstanceExportTaskRequestT& request) const { return SubmitCallable(&EC2Client::CreateInstanceExportTask, request); } /** * An Async wrapper for CreateInstanceExportTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInstanceExportTaskAsync(const CreateInstanceExportTaskRequestT& request, const CreateInstanceExportTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateInstanceExportTask, request, handler, context); } /** *

Creates an internet gateway for use with a VPC. After creating the internet * gateway, you attach it to a VPC using AttachInternetGateway.

For * more information, see Internet * gateways in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateInternetGatewayOutcome CreateInternetGateway(const Model::CreateInternetGatewayRequest& request) const; /** * A Callable wrapper for CreateInternetGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInternetGatewayOutcomeCallable CreateInternetGatewayCallable(const CreateInternetGatewayRequestT& request) const { return SubmitCallable(&EC2Client::CreateInternetGateway, request); } /** * An Async wrapper for CreateInternetGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInternetGatewayAsync(const CreateInternetGatewayRequestT& request, const CreateInternetGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateInternetGateway, request, handler, context); } /** *

Create an IPAM. Amazon VPC IP Address Manager (IPAM) is a VPC feature that * you can use to automate your IP address management workflows including * assigning, tracking, troubleshooting, and auditing IP addresses across Amazon * Web Services Regions and accounts throughout your Amazon Web Services * Organization.

For more information, see Create an * IPAM in the Amazon VPC IPAM User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::CreateIpamOutcome CreateIpam(const Model::CreateIpamRequest& request) const; /** * A Callable wrapper for CreateIpam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIpamOutcomeCallable CreateIpamCallable(const CreateIpamRequestT& request) const { return SubmitCallable(&EC2Client::CreateIpam, request); } /** * An Async wrapper for CreateIpam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIpamAsync(const CreateIpamRequestT& request, const CreateIpamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateIpam, request, handler, context); } /** *

Create an IP address pool for Amazon VPC IP Address Manager (IPAM). In IPAM, * a pool is a collection of contiguous IP addresses CIDRs. Pools enable you to * organize your IP addresses according to your routing and security needs. For * example, if you have separate routing and security needs for development and * production applications, you can create a pool for each.

For more * information, see Create a * top-level pool in the Amazon VPC IPAM User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateIpamPoolOutcome CreateIpamPool(const Model::CreateIpamPoolRequest& request) const; /** * A Callable wrapper for CreateIpamPool that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIpamPoolOutcomeCallable CreateIpamPoolCallable(const CreateIpamPoolRequestT& request) const { return SubmitCallable(&EC2Client::CreateIpamPool, request); } /** * An Async wrapper for CreateIpamPool that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIpamPoolAsync(const CreateIpamPoolRequestT& request, const CreateIpamPoolResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateIpamPool, request, handler, context); } /** *

Creates an IPAM resource discovery. A resource discovery is an IPAM component * that enables IPAM to manage and monitor resources that belong to the owning * account.

See Also:

AWS * API Reference

*/ virtual Model::CreateIpamResourceDiscoveryOutcome CreateIpamResourceDiscovery(const Model::CreateIpamResourceDiscoveryRequest& request) const; /** * A Callable wrapper for CreateIpamResourceDiscovery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIpamResourceDiscoveryOutcomeCallable CreateIpamResourceDiscoveryCallable(const CreateIpamResourceDiscoveryRequestT& request) const { return SubmitCallable(&EC2Client::CreateIpamResourceDiscovery, request); } /** * An Async wrapper for CreateIpamResourceDiscovery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIpamResourceDiscoveryAsync(const CreateIpamResourceDiscoveryRequestT& request, const CreateIpamResourceDiscoveryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateIpamResourceDiscovery, request, handler, context); } /** *

Create an IPAM scope. In IPAM, a scope is the highest-level container within * IPAM. An IPAM contains two default scopes. Each scope represents the IP space * for a single network. The private scope is intended for all private IP address * space. The public scope is intended for all public IP address space. Scopes * enable you to reuse IP addresses across multiple unconnected networks without * causing IP address overlap or conflict.

For more information, see Add a * scope in the Amazon VPC IPAM User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::CreateIpamScopeOutcome CreateIpamScope(const Model::CreateIpamScopeRequest& request) const; /** * A Callable wrapper for CreateIpamScope that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIpamScopeOutcomeCallable CreateIpamScopeCallable(const CreateIpamScopeRequestT& request) const { return SubmitCallable(&EC2Client::CreateIpamScope, request); } /** * An Async wrapper for CreateIpamScope that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIpamScopeAsync(const CreateIpamScopeRequestT& request, const CreateIpamScopeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateIpamScope, request, handler, context); } /** *

Creates an ED25519 or 2048-bit RSA key pair with the specified name and in * the specified PEM or PPK format. Amazon EC2 stores the public key and displays * the private key for you to save to a file. The private key is returned as an * unencrypted PEM encoded PKCS#1 private key or an unencrypted PPK formatted * private key for use with PuTTY. If a key with the specified name already exists, * Amazon EC2 returns an error.

The key pair returned to you is available * only in the Amazon Web Services Region in which you create it. If you prefer, * you can create your own key pair using a third-party tool and upload it to any * Region using ImportKeyPair.

You can have up to 5,000 key pairs per * Amazon Web Services Region.

For more information, see Amazon * EC2 key pairs in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateKeyPairOutcome CreateKeyPair(const Model::CreateKeyPairRequest& request) const; /** * A Callable wrapper for CreateKeyPair that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateKeyPairOutcomeCallable CreateKeyPairCallable(const CreateKeyPairRequestT& request) const { return SubmitCallable(&EC2Client::CreateKeyPair, request); } /** * An Async wrapper for CreateKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateKeyPairAsync(const CreateKeyPairRequestT& request, const CreateKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateKeyPair, request, handler, context); } /** *

Creates a launch template.

A launch template contains the parameters * to launch an instance. When you launch an instance using RunInstances, * you can specify a launch template instead of providing the launch parameters in * the request. For more information, see Launch * an instance from a launch template in the Amazon Elastic Compute Cloud * User Guide.

If you want to clone an existing launch template as the * basis for creating a new launch template, you can use the Amazon EC2 console. * The API, SDKs, and CLI do not support cloning a template. For more information, * see Create * a launch template from an existing launch template in the Amazon Elastic * Compute Cloud User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateLaunchTemplateOutcome CreateLaunchTemplate(const Model::CreateLaunchTemplateRequest& request) const; /** * A Callable wrapper for CreateLaunchTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLaunchTemplateOutcomeCallable CreateLaunchTemplateCallable(const CreateLaunchTemplateRequestT& request) const { return SubmitCallable(&EC2Client::CreateLaunchTemplate, request); } /** * An Async wrapper for CreateLaunchTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLaunchTemplateAsync(const CreateLaunchTemplateRequestT& request, const CreateLaunchTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateLaunchTemplate, request, handler, context); } /** *

Creates a new version of a launch template. You can specify an existing * version of launch template from which to base the new version.

Launch * template versions are numbered in the order in which they are created. You * cannot specify, change, or replace the numbering of launch template * versions.

Launch templates are immutable; after you create a launch * template, you can't modify it. Instead, you can create a new version of the * launch template that includes any changes you require.

For more * information, see Modify * a launch template (manage launch template versions) in the Amazon Elastic * Compute Cloud User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateLaunchTemplateVersionOutcome CreateLaunchTemplateVersion(const Model::CreateLaunchTemplateVersionRequest& request) const; /** * A Callable wrapper for CreateLaunchTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLaunchTemplateVersionOutcomeCallable CreateLaunchTemplateVersionCallable(const CreateLaunchTemplateVersionRequestT& request) const { return SubmitCallable(&EC2Client::CreateLaunchTemplateVersion, request); } /** * An Async wrapper for CreateLaunchTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLaunchTemplateVersionAsync(const CreateLaunchTemplateVersionRequestT& request, const CreateLaunchTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateLaunchTemplateVersion, request, handler, context); } /** *

Creates a static route for the specified local gateway route table. You must * specify one of the following targets:

  • * LocalGatewayVirtualInterfaceGroupId

  • * NetworkInterfaceId

See Also:

AWS * API Reference

*/ virtual Model::CreateLocalGatewayRouteOutcome CreateLocalGatewayRoute(const Model::CreateLocalGatewayRouteRequest& request) const; /** * A Callable wrapper for CreateLocalGatewayRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocalGatewayRouteOutcomeCallable CreateLocalGatewayRouteCallable(const CreateLocalGatewayRouteRequestT& request) const { return SubmitCallable(&EC2Client::CreateLocalGatewayRoute, request); } /** * An Async wrapper for CreateLocalGatewayRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocalGatewayRouteAsync(const CreateLocalGatewayRouteRequestT& request, const CreateLocalGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateLocalGatewayRoute, request, handler, context); } /** *

Creates a local gateway route table.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocalGatewayRouteTableOutcome CreateLocalGatewayRouteTable(const Model::CreateLocalGatewayRouteTableRequest& request) const; /** * A Callable wrapper for CreateLocalGatewayRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocalGatewayRouteTableOutcomeCallable CreateLocalGatewayRouteTableCallable(const CreateLocalGatewayRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::CreateLocalGatewayRouteTable, request); } /** * An Async wrapper for CreateLocalGatewayRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocalGatewayRouteTableAsync(const CreateLocalGatewayRouteTableRequestT& request, const CreateLocalGatewayRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateLocalGatewayRouteTable, request, handler, context); } /** *

Creates a local gateway route table virtual interface group association. *

See Also:

AWS * API Reference

*/ virtual Model::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutcome CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(const Model::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest& request) const; /** * A Callable wrapper for CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutcomeCallable CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationCallable(const CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT& request) const { return SubmitCallable(&EC2Client::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation, request); } /** * An Async wrapper for CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationAsync(const CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT& request, const CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation, request, handler, context); } /** *

Associates the specified VPC with the specified local gateway route * table.

See Also:

AWS * API Reference

*/ virtual Model::CreateLocalGatewayRouteTableVpcAssociationOutcome CreateLocalGatewayRouteTableVpcAssociation(const Model::CreateLocalGatewayRouteTableVpcAssociationRequest& request) const; /** * A Callable wrapper for CreateLocalGatewayRouteTableVpcAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLocalGatewayRouteTableVpcAssociationOutcomeCallable CreateLocalGatewayRouteTableVpcAssociationCallable(const CreateLocalGatewayRouteTableVpcAssociationRequestT& request) const { return SubmitCallable(&EC2Client::CreateLocalGatewayRouteTableVpcAssociation, request); } /** * An Async wrapper for CreateLocalGatewayRouteTableVpcAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLocalGatewayRouteTableVpcAssociationAsync(const CreateLocalGatewayRouteTableVpcAssociationRequestT& request, const CreateLocalGatewayRouteTableVpcAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateLocalGatewayRouteTableVpcAssociation, request, handler, context); } /** *

Creates a managed prefix list. You can specify one or more entries for the * prefix list. Each entry consists of a CIDR block and an optional * description.

See Also:

AWS * API Reference

*/ virtual Model::CreateManagedPrefixListOutcome CreateManagedPrefixList(const Model::CreateManagedPrefixListRequest& request) const; /** * A Callable wrapper for CreateManagedPrefixList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateManagedPrefixListOutcomeCallable CreateManagedPrefixListCallable(const CreateManagedPrefixListRequestT& request) const { return SubmitCallable(&EC2Client::CreateManagedPrefixList, request); } /** * An Async wrapper for CreateManagedPrefixList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateManagedPrefixListAsync(const CreateManagedPrefixListRequestT& request, const CreateManagedPrefixListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateManagedPrefixList, request, handler, context); } /** *

Creates a NAT gateway in the specified subnet. This action creates a network * interface in the specified subnet with a private IP address from the IP address * range of the subnet. You can create either a public NAT gateway or a private NAT * gateway.

With a public NAT gateway, internet-bound traffic from a private * subnet can be routed to the NAT gateway, so that instances in a private subnet * can connect to the internet.

With a private NAT gateway, private * communication is routed across VPCs and on-premises networks through a transit * gateway or virtual private gateway. Common use cases include running large * workloads behind a small pool of allowlisted IPv4 addresses, preserving private * IPv4 addresses, and communicating between overlapping networks.

For more * information, see NAT * gateways in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateNatGatewayOutcome CreateNatGateway(const Model::CreateNatGatewayRequest& request) const; /** * A Callable wrapper for CreateNatGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNatGatewayOutcomeCallable CreateNatGatewayCallable(const CreateNatGatewayRequestT& request) const { return SubmitCallable(&EC2Client::CreateNatGateway, request); } /** * An Async wrapper for CreateNatGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNatGatewayAsync(const CreateNatGatewayRequestT& request, const CreateNatGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateNatGateway, request, handler, context); } /** *

Creates a network ACL in a VPC. Network ACLs provide an optional layer of * security (in addition to security groups) for the instances in your VPC.

*

For more information, see Network * ACLs in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateNetworkAclOutcome CreateNetworkAcl(const Model::CreateNetworkAclRequest& request) const; /** * A Callable wrapper for CreateNetworkAcl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNetworkAclOutcomeCallable CreateNetworkAclCallable(const CreateNetworkAclRequestT& request) const { return SubmitCallable(&EC2Client::CreateNetworkAcl, request); } /** * An Async wrapper for CreateNetworkAcl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNetworkAclAsync(const CreateNetworkAclRequestT& request, const CreateNetworkAclResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateNetworkAcl, request, handler, context); } /** *

Creates an entry (a rule) in a network ACL with the specified rule number. * Each network ACL has a set of numbered ingress rules and a separate set of * numbered egress rules. When determining whether a packet should be allowed in or * out of a subnet associated with the ACL, we process the entries in the ACL * according to the rule numbers, in ascending order. Each network ACL has a set of * ingress rules and a separate set of egress rules.

We recommend that you * leave room between the rule numbers (for example, 100, 110, 120, ...), and not * number them one right after the other (for example, 101, 102, 103, ...). This * makes it easier to add a rule between existing ones without having to renumber * the rules.

After you add an entry, you can't modify it; you must either * replace it, or create an entry and delete the old one.

For more * information about network ACLs, see Network * ACLs in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateNetworkAclEntryOutcome CreateNetworkAclEntry(const Model::CreateNetworkAclEntryRequest& request) const; /** * A Callable wrapper for CreateNetworkAclEntry that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNetworkAclEntryOutcomeCallable CreateNetworkAclEntryCallable(const CreateNetworkAclEntryRequestT& request) const { return SubmitCallable(&EC2Client::CreateNetworkAclEntry, request); } /** * An Async wrapper for CreateNetworkAclEntry that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNetworkAclEntryAsync(const CreateNetworkAclEntryRequestT& request, const CreateNetworkAclEntryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateNetworkAclEntry, request, handler, context); } /** *

Creates a Network Access Scope.

Amazon Web Services Network Access * Analyzer enables cloud networking and cloud operations teams to verify that * their networks on Amazon Web Services conform to their network security and * governance objectives. For more information, see the Amazon * Web Services Network Access Analyzer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateNetworkInsightsAccessScopeOutcome CreateNetworkInsightsAccessScope(const Model::CreateNetworkInsightsAccessScopeRequest& request) const; /** * A Callable wrapper for CreateNetworkInsightsAccessScope that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNetworkInsightsAccessScopeOutcomeCallable CreateNetworkInsightsAccessScopeCallable(const CreateNetworkInsightsAccessScopeRequestT& request) const { return SubmitCallable(&EC2Client::CreateNetworkInsightsAccessScope, request); } /** * An Async wrapper for CreateNetworkInsightsAccessScope that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNetworkInsightsAccessScopeAsync(const CreateNetworkInsightsAccessScopeRequestT& request, const CreateNetworkInsightsAccessScopeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateNetworkInsightsAccessScope, request, handler, context); } /** *

Creates a path to analyze for reachability.

Reachability Analyzer * enables you to analyze and debug network reachability between two resources in * your virtual private cloud (VPC). For more information, see the Reachability * Analyzer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateNetworkInsightsPathOutcome CreateNetworkInsightsPath(const Model::CreateNetworkInsightsPathRequest& request) const; /** * A Callable wrapper for CreateNetworkInsightsPath that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNetworkInsightsPathOutcomeCallable CreateNetworkInsightsPathCallable(const CreateNetworkInsightsPathRequestT& request) const { return SubmitCallable(&EC2Client::CreateNetworkInsightsPath, request); } /** * An Async wrapper for CreateNetworkInsightsPath that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNetworkInsightsPathAsync(const CreateNetworkInsightsPathRequestT& request, const CreateNetworkInsightsPathResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateNetworkInsightsPath, request, handler, context); } /** *

Creates a network interface in the specified subnet.

The number of IP * addresses you can assign to a network interface varies by instance type. For * more information, see IP * Addresses Per ENI Per Instance Type in the Amazon Virtual Private Cloud * User Guide.

For more information about network interfaces, see Elastic * network interfaces in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateNetworkInterfaceOutcome CreateNetworkInterface(const Model::CreateNetworkInterfaceRequest& request) const; /** * A Callable wrapper for CreateNetworkInterface that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNetworkInterfaceOutcomeCallable CreateNetworkInterfaceCallable(const CreateNetworkInterfaceRequestT& request) const { return SubmitCallable(&EC2Client::CreateNetworkInterface, request); } /** * An Async wrapper for CreateNetworkInterface that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNetworkInterfaceAsync(const CreateNetworkInterfaceRequestT& request, const CreateNetworkInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateNetworkInterface, request, handler, context); } /** *

Grants an Amazon Web Services-authorized account permission to attach the * specified network interface to an instance in their account.

You can * grant permission to a single Amazon Web Services account only, and only one * account at a time.

See Also:

AWS * API Reference

*/ virtual Model::CreateNetworkInterfacePermissionOutcome CreateNetworkInterfacePermission(const Model::CreateNetworkInterfacePermissionRequest& request) const; /** * A Callable wrapper for CreateNetworkInterfacePermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNetworkInterfacePermissionOutcomeCallable CreateNetworkInterfacePermissionCallable(const CreateNetworkInterfacePermissionRequestT& request) const { return SubmitCallable(&EC2Client::CreateNetworkInterfacePermission, request); } /** * An Async wrapper for CreateNetworkInterfacePermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNetworkInterfacePermissionAsync(const CreateNetworkInterfacePermissionRequestT& request, const CreateNetworkInterfacePermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateNetworkInterfacePermission, request, handler, context); } /** *

Creates a placement group in which to launch instances. The strategy of the * placement group determines how the instances are organized within the group. *

A cluster placement group is a logical grouping of * instances within a single Availability Zone that benefit from low network * latency, high network throughput. A spread placement group places * instances on distinct hardware. A partition placement group places * groups of instances in different partitions, where instances in one partition do * not share the same hardware with instances in another partition.

For more * information, see Placement * groups in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreatePlacementGroupOutcome CreatePlacementGroup(const Model::CreatePlacementGroupRequest& request) const; /** * A Callable wrapper for CreatePlacementGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePlacementGroupOutcomeCallable CreatePlacementGroupCallable(const CreatePlacementGroupRequestT& request) const { return SubmitCallable(&EC2Client::CreatePlacementGroup, request); } /** * An Async wrapper for CreatePlacementGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePlacementGroupAsync(const CreatePlacementGroupRequestT& request, const CreatePlacementGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreatePlacementGroup, request, handler, context); } /** *

Creates a public IPv4 address pool. A public IPv4 pool is an EC2 IP address * pool required for the public IPv4 CIDRs that you own and bring to Amazon Web * Services to manage with IPAM. IPv6 addresses you bring to Amazon Web Services, * however, use IPAM pools only. To monitor the status of pool creation, use DescribePublicIpv4Pools.

See * Also:

AWS * API Reference

*/ virtual Model::CreatePublicIpv4PoolOutcome CreatePublicIpv4Pool(const Model::CreatePublicIpv4PoolRequest& request) const; /** * A Callable wrapper for CreatePublicIpv4Pool that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePublicIpv4PoolOutcomeCallable CreatePublicIpv4PoolCallable(const CreatePublicIpv4PoolRequestT& request) const { return SubmitCallable(&EC2Client::CreatePublicIpv4Pool, request); } /** * An Async wrapper for CreatePublicIpv4Pool that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePublicIpv4PoolAsync(const CreatePublicIpv4PoolRequestT& request, const CreatePublicIpv4PoolResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreatePublicIpv4Pool, request, handler, context); } /** *

Replaces the EBS-backed root volume for a running instance with * a new volume that is restored to the original root volume's launch state, that * is restored to a specific snapshot taken from the original root volume, or that * is restored from an AMI that has the same key characteristics as that of the * instance.

For more information, see Replace * a root volume in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateReplaceRootVolumeTaskOutcome CreateReplaceRootVolumeTask(const Model::CreateReplaceRootVolumeTaskRequest& request) const; /** * A Callable wrapper for CreateReplaceRootVolumeTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateReplaceRootVolumeTaskOutcomeCallable CreateReplaceRootVolumeTaskCallable(const CreateReplaceRootVolumeTaskRequestT& request) const { return SubmitCallable(&EC2Client::CreateReplaceRootVolumeTask, request); } /** * An Async wrapper for CreateReplaceRootVolumeTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateReplaceRootVolumeTaskAsync(const CreateReplaceRootVolumeTaskRequestT& request, const CreateReplaceRootVolumeTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateReplaceRootVolumeTask, request, handler, context); } /** *

Creates a listing for Amazon EC2 Standard Reserved Instances to be sold in * the Reserved Instance Marketplace. You can submit one Standard Reserved Instance * listing at a time. To get a list of your Standard Reserved Instances, you can * use the DescribeReservedInstances operation.

Only Standard * Reserved Instances can be sold in the Reserved Instance Marketplace. Convertible * Reserved Instances cannot be sold.

The Reserved Instance * Marketplace matches sellers who want to resell Standard Reserved Instance * capacity that they no longer need with buyers who want to purchase additional * capacity. Reserved Instances bought and sold through the Reserved Instance * Marketplace work like any other Reserved Instances.

To sell your Standard * Reserved Instances, you must first register as a seller in the Reserved Instance * Marketplace. After completing the registration process, you can create a * Reserved Instance Marketplace listing of some or all of your Standard Reserved * Instances, and specify the upfront price to receive for them. Your Standard * Reserved Instance listings then become available for purchase. To view the * details of your Standard Reserved Instance listing, you can use the * DescribeReservedInstancesListings operation.

For more information, * see Reserved * Instance Marketplace in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateReservedInstancesListingOutcome CreateReservedInstancesListing(const Model::CreateReservedInstancesListingRequest& request) const; /** * A Callable wrapper for CreateReservedInstancesListing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateReservedInstancesListingOutcomeCallable CreateReservedInstancesListingCallable(const CreateReservedInstancesListingRequestT& request) const { return SubmitCallable(&EC2Client::CreateReservedInstancesListing, request); } /** * An Async wrapper for CreateReservedInstancesListing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateReservedInstancesListingAsync(const CreateReservedInstancesListingRequestT& request, const CreateReservedInstancesListingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateReservedInstancesListing, request, handler, context); } /** *

Starts a task that restores an AMI from an Amazon S3 object that was * previously created by using CreateStoreImageTask.

*

To use this API, you must have the required permissions. For more * information, see Permissions * for storing and restoring AMIs using Amazon S3 in the Amazon EC2 User * Guide.

For more information, see Store * and restore an AMI using Amazon S3 in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateRestoreImageTaskOutcome CreateRestoreImageTask(const Model::CreateRestoreImageTaskRequest& request) const; /** * A Callable wrapper for CreateRestoreImageTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRestoreImageTaskOutcomeCallable CreateRestoreImageTaskCallable(const CreateRestoreImageTaskRequestT& request) const { return SubmitCallable(&EC2Client::CreateRestoreImageTask, request); } /** * An Async wrapper for CreateRestoreImageTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRestoreImageTaskAsync(const CreateRestoreImageTaskRequestT& request, const CreateRestoreImageTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateRestoreImageTask, request, handler, context); } /** *

Creates a route in a route table within a VPC.

You must specify either * a destination CIDR block or a prefix list ID. You must also specify exactly one * of the resources from the parameter list.

When determining how to route * traffic, we use the route with the most specific match. For example, traffic is * destined for the IPv4 address 192.0.2.3, and the route table * includes the following two IPv4 routes:

  • * 192.0.2.0/24 (goes to some target A)

  • * 192.0.2.0/28 (goes to some target B)

Both routes * apply to the traffic destined for 192.0.2.3. However, the second * route in the list covers a smaller number of IP addresses and is therefore more * specific, so we use that route to determine where to target the traffic.

*

For more information about route tables, see Route * tables in the Amazon VPC User Guide.

See Also:

AWS API * Reference

*/ virtual Model::CreateRouteOutcome CreateRoute(const Model::CreateRouteRequest& request) const; /** * A Callable wrapper for CreateRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRouteOutcomeCallable CreateRouteCallable(const CreateRouteRequestT& request) const { return SubmitCallable(&EC2Client::CreateRoute, request); } /** * An Async wrapper for CreateRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRouteAsync(const CreateRouteRequestT& request, const CreateRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateRoute, request, handler, context); } /** *

Creates a route table for the specified VPC. After you create a route table, * you can add routes and associate the table with a subnet.

For more * information, see Route * tables in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateRouteTableOutcome CreateRouteTable(const Model::CreateRouteTableRequest& request) const; /** * A Callable wrapper for CreateRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRouteTableOutcomeCallable CreateRouteTableCallable(const CreateRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::CreateRouteTable, request); } /** * An Async wrapper for CreateRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRouteTableAsync(const CreateRouteTableRequestT& request, const CreateRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateRouteTable, request, handler, context); } /** *

Creates a security group.

A security group acts as a virtual firewall * for your instance to control inbound and outbound traffic. For more information, * see Amazon * EC2 security groups in the Amazon Elastic Compute Cloud User Guide * and Security * groups for your VPC in the Amazon Virtual Private Cloud User * Guide.

When you create a security group, you specify a friendly name * of your choice. You can't have two security groups for the same VPC with the * same name.

You have a default security group for use in your VPC. If you * don't specify a security group when you launch an instance, the instance is * launched into the appropriate default security group. A default security group * includes a default rule that grants instances unrestricted network access to * each other.

You can add or remove rules from your security groups using * AuthorizeSecurityGroupIngress, AuthorizeSecurityGroupEgress, * RevokeSecurityGroupIngress, and RevokeSecurityGroupEgress.

*

For more information about VPC security group limits, see Amazon * VPC Limits.

See Also:

AWS * API Reference

*/ virtual Model::CreateSecurityGroupOutcome CreateSecurityGroup(const Model::CreateSecurityGroupRequest& request) const; /** * A Callable wrapper for CreateSecurityGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSecurityGroupOutcomeCallable CreateSecurityGroupCallable(const CreateSecurityGroupRequestT& request) const { return SubmitCallable(&EC2Client::CreateSecurityGroup, request); } /** * An Async wrapper for CreateSecurityGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSecurityGroupAsync(const CreateSecurityGroupRequestT& request, const CreateSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateSecurityGroup, request, handler, context); } /** *

Creates a snapshot of an EBS volume and stores it in Amazon S3. You can use * snapshots for backups, to make copies of EBS volumes, and to save data before * shutting down an instance.

You can create snapshots of volumes in a * Region and volumes on an Outpost. If you create a snapshot of a volume in a * Region, the snapshot must be stored in the same Region as the volume. If you * create a snapshot of a volume on an Outpost, the snapshot can be stored on the * same Outpost as the volume, or in the Region for that Outpost.

When a * snapshot is created, any Amazon Web Services Marketplace product codes that are * associated with the source volume are propagated to the snapshot.

You can * take a snapshot of an attached volume that is in use. However, snapshots only * capture data that has been written to your Amazon EBS volume at the time the * snapshot command is issued; this might exclude any data that has been cached by * any applications or the operating system. If you can pause any file systems on * the volume long enough to take a snapshot, your snapshot should be complete. * However, if you cannot pause all file writes to the volume, you should unmount * the volume from within the instance, issue the snapshot command, and then * remount the volume to ensure a consistent and complete snapshot. You may remount * and use your volume while the snapshot status is pending.

*

When you create a snapshot for an EBS volume that serves as a root device, we * recommend that you stop the instance before taking the snapshot.

*

Snapshots that are taken from encrypted volumes are automatically encrypted. * Volumes that are created from encrypted snapshots are also automatically * encrypted. Your encrypted volumes and any associated snapshots always remain * protected.

You can tag your snapshots during creation. For more * information, see Tag * your Amazon EC2 resources in the Amazon Elastic Compute Cloud User * Guide.

For more information, see Amazon * Elastic Block Store and Amazon * EBS encryption in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateSnapshotOutcome CreateSnapshot(const Model::CreateSnapshotRequest& request) const; /** * A Callable wrapper for CreateSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSnapshotOutcomeCallable CreateSnapshotCallable(const CreateSnapshotRequestT& request) const { return SubmitCallable(&EC2Client::CreateSnapshot, request); } /** * An Async wrapper for CreateSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSnapshotAsync(const CreateSnapshotRequestT& request, const CreateSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateSnapshot, request, handler, context); } /** *

Creates crash-consistent snapshots of multiple EBS volumes and stores the * data in S3. Volumes are chosen by specifying an instance. Any attached volumes * will produce one snapshot each that is crash-consistent across the instance.

*

You can include all of the volumes currently attached to the instance, or you * can exclude the root volume or specific data (non-root) volumes from the * multi-volume snapshot set.

You can create multi-volume snapshots of * instances in a Region and instances on an Outpost. If you create snapshots from * an instance in a Region, the snapshots must be stored in the same Region as the * instance. If you create snapshots from an instance on an Outpost, the snapshots * can be stored on the same Outpost as the instance, or in the Region for that * Outpost.

See Also:

AWS * API Reference

*/ virtual Model::CreateSnapshotsOutcome CreateSnapshots(const Model::CreateSnapshotsRequest& request) const; /** * A Callable wrapper for CreateSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSnapshotsOutcomeCallable CreateSnapshotsCallable(const CreateSnapshotsRequestT& request) const { return SubmitCallable(&EC2Client::CreateSnapshots, request); } /** * An Async wrapper for CreateSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSnapshotsAsync(const CreateSnapshotsRequestT& request, const CreateSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateSnapshots, request, handler, context); } /** *

Creates a data feed for Spot Instances, enabling you to view Spot Instance * usage logs. You can create one data feed per Amazon Web Services account. For * more information, see Spot * Instance data feed in the Amazon EC2 User Guide for Linux * Instances.

See Also:

AWS * API Reference

*/ virtual Model::CreateSpotDatafeedSubscriptionOutcome CreateSpotDatafeedSubscription(const Model::CreateSpotDatafeedSubscriptionRequest& request) const; /** * A Callable wrapper for CreateSpotDatafeedSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSpotDatafeedSubscriptionOutcomeCallable CreateSpotDatafeedSubscriptionCallable(const CreateSpotDatafeedSubscriptionRequestT& request) const { return SubmitCallable(&EC2Client::CreateSpotDatafeedSubscription, request); } /** * An Async wrapper for CreateSpotDatafeedSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSpotDatafeedSubscriptionAsync(const CreateSpotDatafeedSubscriptionRequestT& request, const CreateSpotDatafeedSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateSpotDatafeedSubscription, request, handler, context); } /** *

Stores an AMI as a single object in an Amazon S3 bucket.

To use this * API, you must have the required permissions. For more information, see Permissions * for storing and restoring AMIs using Amazon S3 in the Amazon EC2 User * Guide.

For more information, see Store * and restore an AMI using Amazon S3 in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateStoreImageTaskOutcome CreateStoreImageTask(const Model::CreateStoreImageTaskRequest& request) const; /** * A Callable wrapper for CreateStoreImageTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStoreImageTaskOutcomeCallable CreateStoreImageTaskCallable(const CreateStoreImageTaskRequestT& request) const { return SubmitCallable(&EC2Client::CreateStoreImageTask, request); } /** * An Async wrapper for CreateStoreImageTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStoreImageTaskAsync(const CreateStoreImageTaskRequestT& request, const CreateStoreImageTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateStoreImageTask, request, handler, context); } /** *

Creates a subnet in the specified VPC. For an IPv4 only subnet, specify an * IPv4 CIDR block. If the VPC has an IPv6 CIDR block, you can create an IPv6 only * subnet or a dual stack subnet instead. For an IPv6 only subnet, specify an IPv6 * CIDR block. For a dual stack subnet, specify both an IPv4 CIDR block and an IPv6 * CIDR block.

A subnet CIDR block must not overlap the CIDR block of an * existing subnet in the VPC. After you create a subnet, you can't change its CIDR * block.

The allowed size for an IPv4 subnet is between a /28 netmask (16 * IP addresses) and a /16 netmask (65,536 IP addresses). Amazon Web Services * reserves both the first four and the last IPv4 address in each subnet's CIDR * block. They're not available for your use.

If you've associated an IPv6 * CIDR block with your VPC, you can associate an IPv6 CIDR block with a subnet * when you create it. The allowed block size for an IPv6 subnet is a /64 * netmask.

If you add more than one subnet to a VPC, they're set up in a * star topology with a logical router in the middle.

When you stop an * instance in a subnet, it retains its private IPv4 address. It's therefore * possible to have a subnet with no running instances (they're all stopped), but * no remaining IP addresses available.

For more information, see Subnets * in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateSubnetOutcome CreateSubnet(const Model::CreateSubnetRequest& request) const; /** * A Callable wrapper for CreateSubnet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSubnetOutcomeCallable CreateSubnetCallable(const CreateSubnetRequestT& request) const { return SubmitCallable(&EC2Client::CreateSubnet, request); } /** * An Async wrapper for CreateSubnet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSubnetAsync(const CreateSubnetRequestT& request, const CreateSubnetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateSubnet, request, handler, context); } /** *

Creates a subnet CIDR reservation. For information about subnet CIDR * reservations, see Subnet * CIDR reservations in the Amazon Virtual Private Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateSubnetCidrReservationOutcome CreateSubnetCidrReservation(const Model::CreateSubnetCidrReservationRequest& request) const; /** * A Callable wrapper for CreateSubnetCidrReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSubnetCidrReservationOutcomeCallable CreateSubnetCidrReservationCallable(const CreateSubnetCidrReservationRequestT& request) const { return SubmitCallable(&EC2Client::CreateSubnetCidrReservation, request); } /** * An Async wrapper for CreateSubnetCidrReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSubnetCidrReservationAsync(const CreateSubnetCidrReservationRequestT& request, const CreateSubnetCidrReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateSubnetCidrReservation, request, handler, context); } /** *

Adds or overwrites only the specified tags for the specified Amazon EC2 * resource or resources. When you specify an existing tag key, the value is * overwritten with the new value. Each resource can have a maximum of 50 tags. * Each tag consists of a key and optional value. Tag keys must be unique per * resource.

For more information about tags, see Tag * your Amazon EC2 resources in the Amazon Elastic Compute Cloud User * Guide. For more information about creating IAM policies that control users' * access to resources based on tags, see Supported * resource-level permissions for Amazon EC2 API actions in the Amazon * Elastic Compute Cloud User Guide.

See Also:

AWS API * Reference

*/ virtual Model::CreateTagsOutcome CreateTags(const Model::CreateTagsRequest& request) const; /** * A Callable wrapper for CreateTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTagsOutcomeCallable CreateTagsCallable(const CreateTagsRequestT& request) const { return SubmitCallable(&EC2Client::CreateTags, request); } /** * An Async wrapper for CreateTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTagsAsync(const CreateTagsRequestT& request, const CreateTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTags, request, handler, context); } /** *

Creates a Traffic Mirror filter.

A Traffic Mirror filter is a set of * rules that defines the traffic to mirror.

By default, no traffic is * mirrored. To mirror traffic, use CreateTrafficMirrorFilterRule * to add Traffic Mirror rules to the filter. The rules you add define what traffic * gets mirrored. You can also use ModifyTrafficMirrorFilterNetworkServices * to mirror supported network services.

See Also:

AWS * API Reference

*/ virtual Model::CreateTrafficMirrorFilterOutcome CreateTrafficMirrorFilter(const Model::CreateTrafficMirrorFilterRequest& request) const; /** * A Callable wrapper for CreateTrafficMirrorFilter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrafficMirrorFilterOutcomeCallable CreateTrafficMirrorFilterCallable(const CreateTrafficMirrorFilterRequestT& request) const { return SubmitCallable(&EC2Client::CreateTrafficMirrorFilter, request); } /** * An Async wrapper for CreateTrafficMirrorFilter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrafficMirrorFilterAsync(const CreateTrafficMirrorFilterRequestT& request, const CreateTrafficMirrorFilterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTrafficMirrorFilter, request, handler, context); } /** *

Creates a Traffic Mirror filter rule.

A Traffic Mirror rule defines * the Traffic Mirror source traffic to mirror.

You need the Traffic Mirror * filter ID when you create the rule.

See Also:

AWS * API Reference

*/ virtual Model::CreateTrafficMirrorFilterRuleOutcome CreateTrafficMirrorFilterRule(const Model::CreateTrafficMirrorFilterRuleRequest& request) const; /** * A Callable wrapper for CreateTrafficMirrorFilterRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrafficMirrorFilterRuleOutcomeCallable CreateTrafficMirrorFilterRuleCallable(const CreateTrafficMirrorFilterRuleRequestT& request) const { return SubmitCallable(&EC2Client::CreateTrafficMirrorFilterRule, request); } /** * An Async wrapper for CreateTrafficMirrorFilterRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrafficMirrorFilterRuleAsync(const CreateTrafficMirrorFilterRuleRequestT& request, const CreateTrafficMirrorFilterRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTrafficMirrorFilterRule, request, handler, context); } /** *

Creates a Traffic Mirror session.

A Traffic Mirror session actively * copies packets from a Traffic Mirror source to a Traffic Mirror target. Create a * filter, and then assign it to the session to define a subset of the traffic to * mirror, for example all TCP traffic.

The Traffic Mirror source and the * Traffic Mirror target (monitoring appliances) can be in the same VPC, or in a * different VPC connected via VPC peering or a transit gateway.

By * default, no traffic is mirrored. Use CreateTrafficMirrorFilter * to create filter rules that specify the traffic to mirror.

See * Also:

AWS * API Reference

*/ virtual Model::CreateTrafficMirrorSessionOutcome CreateTrafficMirrorSession(const Model::CreateTrafficMirrorSessionRequest& request) const; /** * A Callable wrapper for CreateTrafficMirrorSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrafficMirrorSessionOutcomeCallable CreateTrafficMirrorSessionCallable(const CreateTrafficMirrorSessionRequestT& request) const { return SubmitCallable(&EC2Client::CreateTrafficMirrorSession, request); } /** * An Async wrapper for CreateTrafficMirrorSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrafficMirrorSessionAsync(const CreateTrafficMirrorSessionRequestT& request, const CreateTrafficMirrorSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTrafficMirrorSession, request, handler, context); } /** *

Creates a target for your Traffic Mirror session.

A Traffic Mirror * target is the destination for mirrored traffic. The Traffic Mirror source and * the Traffic Mirror target (monitoring appliances) can be in the same VPC, or in * different VPCs connected via VPC peering or a transit gateway.

A Traffic * Mirror target can be a network interface, a Network Load Balancer, or a Gateway * Load Balancer endpoint.

To use the target in a Traffic Mirror session, * use CreateTrafficMirrorSession.

See * Also:

AWS * API Reference

*/ virtual Model::CreateTrafficMirrorTargetOutcome CreateTrafficMirrorTarget(const Model::CreateTrafficMirrorTargetRequest& request) const; /** * A Callable wrapper for CreateTrafficMirrorTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrafficMirrorTargetOutcomeCallable CreateTrafficMirrorTargetCallable(const CreateTrafficMirrorTargetRequestT& request) const { return SubmitCallable(&EC2Client::CreateTrafficMirrorTarget, request); } /** * An Async wrapper for CreateTrafficMirrorTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrafficMirrorTargetAsync(const CreateTrafficMirrorTargetRequestT& request, const CreateTrafficMirrorTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTrafficMirrorTarget, request, handler, context); } /** *

Creates a transit gateway.

You can use a transit gateway to * interconnect your virtual private clouds (VPC) and on-premises networks. After * the transit gateway enters the available state, you can attach your * VPCs and VPN connections to the transit gateway.

To attach your VPCs, use * CreateTransitGatewayVpcAttachment.

To attach a VPN connection, use * CreateCustomerGateway to create a customer gateway and specify the ID of * the customer gateway and the ID of the transit gateway in a call to * CreateVpnConnection.

When you create a transit gateway, we create * a default transit gateway route table and use it as the default association * route table and the default propagation route table. You can use * CreateTransitGatewayRouteTable to create additional transit gateway route * tables. If you disable automatic route propagation, we do not create a default * transit gateway route table. You can use * EnableTransitGatewayRouteTablePropagation to propagate routes from a * resource attachment to a transit gateway route table. If you disable automatic * associations, you can use AssociateTransitGatewayRouteTable to associate * a resource attachment with a transit gateway route table.

See * Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayOutcome CreateTransitGateway(const Model::CreateTransitGatewayRequest& request) const; /** * A Callable wrapper for CreateTransitGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayOutcomeCallable CreateTransitGatewayCallable(const CreateTransitGatewayRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGateway, request); } /** * An Async wrapper for CreateTransitGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayAsync(const CreateTransitGatewayRequestT& request, const CreateTransitGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGateway, request, handler, context); } /** *

Creates a Connect attachment from a specified transit gateway attachment. A * Connect attachment is a GRE-based tunnel attachment that you can use to * establish a connection between a transit gateway and an appliance.

A * Connect attachment uses an existing VPC or Amazon Web Services Direct Connect * attachment as the underlying transport mechanism.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayConnectOutcome CreateTransitGatewayConnect(const Model::CreateTransitGatewayConnectRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayConnect that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayConnectOutcomeCallable CreateTransitGatewayConnectCallable(const CreateTransitGatewayConnectRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayConnect, request); } /** * An Async wrapper for CreateTransitGatewayConnect that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayConnectAsync(const CreateTransitGatewayConnectRequestT& request, const CreateTransitGatewayConnectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayConnect, request, handler, context); } /** *

Creates a Connect peer for a specified transit gateway Connect attachment * between a transit gateway and an appliance.

The peer address and transit * gateway address must be the same IP address family (IPv4 or IPv6).

For * more information, see Connect * peers in the Transit Gateways Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayConnectPeerOutcome CreateTransitGatewayConnectPeer(const Model::CreateTransitGatewayConnectPeerRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayConnectPeer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayConnectPeerOutcomeCallable CreateTransitGatewayConnectPeerCallable(const CreateTransitGatewayConnectPeerRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayConnectPeer, request); } /** * An Async wrapper for CreateTransitGatewayConnectPeer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayConnectPeerAsync(const CreateTransitGatewayConnectPeerRequestT& request, const CreateTransitGatewayConnectPeerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayConnectPeer, request, handler, context); } /** *

Creates a multicast domain using the specified transit gateway.

The * transit gateway must be in the available state before you create a domain. Use * DescribeTransitGateways * to see the state of transit gateway.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayMulticastDomainOutcome CreateTransitGatewayMulticastDomain(const Model::CreateTransitGatewayMulticastDomainRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayMulticastDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayMulticastDomainOutcomeCallable CreateTransitGatewayMulticastDomainCallable(const CreateTransitGatewayMulticastDomainRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayMulticastDomain, request); } /** * An Async wrapper for CreateTransitGatewayMulticastDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayMulticastDomainAsync(const CreateTransitGatewayMulticastDomainRequestT& request, const CreateTransitGatewayMulticastDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayMulticastDomain, request, handler, context); } /** *

Requests a transit gateway peering attachment between the specified transit * gateway (requester) and a peer transit gateway (accepter). The peer transit * gateway can be in your account or a different Amazon Web Services account.

*

After you create the peering attachment, the owner of the accepter transit * gateway must accept the attachment request.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayPeeringAttachmentOutcome CreateTransitGatewayPeeringAttachment(const Model::CreateTransitGatewayPeeringAttachmentRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayPeeringAttachment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayPeeringAttachmentOutcomeCallable CreateTransitGatewayPeeringAttachmentCallable(const CreateTransitGatewayPeeringAttachmentRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayPeeringAttachment, request); } /** * An Async wrapper for CreateTransitGatewayPeeringAttachment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayPeeringAttachmentAsync(const CreateTransitGatewayPeeringAttachmentRequestT& request, const CreateTransitGatewayPeeringAttachmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayPeeringAttachment, request, handler, context); } /** *

Creates a transit gateway policy table.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayPolicyTableOutcome CreateTransitGatewayPolicyTable(const Model::CreateTransitGatewayPolicyTableRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayPolicyTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayPolicyTableOutcomeCallable CreateTransitGatewayPolicyTableCallable(const CreateTransitGatewayPolicyTableRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayPolicyTable, request); } /** * An Async wrapper for CreateTransitGatewayPolicyTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayPolicyTableAsync(const CreateTransitGatewayPolicyTableRequestT& request, const CreateTransitGatewayPolicyTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayPolicyTable, request, handler, context); } /** *

Creates a reference (route) to a prefix list in a specified transit gateway * route table.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayPrefixListReferenceOutcome CreateTransitGatewayPrefixListReference(const Model::CreateTransitGatewayPrefixListReferenceRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayPrefixListReference that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayPrefixListReferenceOutcomeCallable CreateTransitGatewayPrefixListReferenceCallable(const CreateTransitGatewayPrefixListReferenceRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayPrefixListReference, request); } /** * An Async wrapper for CreateTransitGatewayPrefixListReference that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayPrefixListReferenceAsync(const CreateTransitGatewayPrefixListReferenceRequestT& request, const CreateTransitGatewayPrefixListReferenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayPrefixListReference, request, handler, context); } /** *

Creates a static route for the specified transit gateway route * table.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayRouteOutcome CreateTransitGatewayRoute(const Model::CreateTransitGatewayRouteRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayRouteOutcomeCallable CreateTransitGatewayRouteCallable(const CreateTransitGatewayRouteRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayRoute, request); } /** * An Async wrapper for CreateTransitGatewayRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayRouteAsync(const CreateTransitGatewayRouteRequestT& request, const CreateTransitGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayRoute, request, handler, context); } /** *

Creates a route table for the specified transit gateway.

See * Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayRouteTableOutcome CreateTransitGatewayRouteTable(const Model::CreateTransitGatewayRouteTableRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayRouteTableOutcomeCallable CreateTransitGatewayRouteTableCallable(const CreateTransitGatewayRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayRouteTable, request); } /** * An Async wrapper for CreateTransitGatewayRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayRouteTableAsync(const CreateTransitGatewayRouteTableRequestT& request, const CreateTransitGatewayRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayRouteTable, request, handler, context); } /** *

Advertises a new transit gateway route table.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayRouteTableAnnouncementOutcome CreateTransitGatewayRouteTableAnnouncement(const Model::CreateTransitGatewayRouteTableAnnouncementRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayRouteTableAnnouncement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayRouteTableAnnouncementOutcomeCallable CreateTransitGatewayRouteTableAnnouncementCallable(const CreateTransitGatewayRouteTableAnnouncementRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayRouteTableAnnouncement, request); } /** * An Async wrapper for CreateTransitGatewayRouteTableAnnouncement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayRouteTableAnnouncementAsync(const CreateTransitGatewayRouteTableAnnouncementRequestT& request, const CreateTransitGatewayRouteTableAnnouncementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayRouteTableAnnouncement, request, handler, context); } /** *

Attaches the specified VPC to the specified transit gateway.

If you * attach a VPC with a CIDR range that overlaps the CIDR range of a VPC that is * already attached, the new VPC CIDR range is not propagated to the default * propagation route table.

To send VPC traffic to an attached transit * gateway, add a route to the VPC route table using * CreateRoute.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransitGatewayVpcAttachmentOutcome CreateTransitGatewayVpcAttachment(const Model::CreateTransitGatewayVpcAttachmentRequest& request) const; /** * A Callable wrapper for CreateTransitGatewayVpcAttachment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransitGatewayVpcAttachmentOutcomeCallable CreateTransitGatewayVpcAttachmentCallable(const CreateTransitGatewayVpcAttachmentRequestT& request) const { return SubmitCallable(&EC2Client::CreateTransitGatewayVpcAttachment, request); } /** * An Async wrapper for CreateTransitGatewayVpcAttachment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransitGatewayVpcAttachmentAsync(const CreateTransitGatewayVpcAttachmentRequestT& request, const CreateTransitGatewayVpcAttachmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateTransitGatewayVpcAttachment, request, handler, context); } /** *

An Amazon Web Services Verified Access endpoint is where you define your * application along with an optional endpoint-level access policy.

See * Also:

AWS * API Reference

*/ virtual Model::CreateVerifiedAccessEndpointOutcome CreateVerifiedAccessEndpoint(const Model::CreateVerifiedAccessEndpointRequest& request) const; /** * A Callable wrapper for CreateVerifiedAccessEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVerifiedAccessEndpointOutcomeCallable CreateVerifiedAccessEndpointCallable(const CreateVerifiedAccessEndpointRequestT& request) const { return SubmitCallable(&EC2Client::CreateVerifiedAccessEndpoint, request); } /** * An Async wrapper for CreateVerifiedAccessEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVerifiedAccessEndpointAsync(const CreateVerifiedAccessEndpointRequestT& request, const CreateVerifiedAccessEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVerifiedAccessEndpoint, request, handler, context); } /** *

An Amazon Web Services Verified Access group is a collection of Amazon Web * Services Verified Access endpoints who's associated applications have similar * security requirements. Each instance within a Verified Access group shares an * Verified Access policy. For example, you can group all Verified Access instances * associated with "sales" applications together and use one common Verified Access * policy.

See Also:

AWS * API Reference

*/ virtual Model::CreateVerifiedAccessGroupOutcome CreateVerifiedAccessGroup(const Model::CreateVerifiedAccessGroupRequest& request) const; /** * A Callable wrapper for CreateVerifiedAccessGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVerifiedAccessGroupOutcomeCallable CreateVerifiedAccessGroupCallable(const CreateVerifiedAccessGroupRequestT& request) const { return SubmitCallable(&EC2Client::CreateVerifiedAccessGroup, request); } /** * An Async wrapper for CreateVerifiedAccessGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVerifiedAccessGroupAsync(const CreateVerifiedAccessGroupRequestT& request, const CreateVerifiedAccessGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVerifiedAccessGroup, request, handler, context); } /** *

An Amazon Web Services Verified Access instance is a regional entity that * evaluates application requests and grants access only when your security * requirements are met.

See Also:

AWS * API Reference

*/ virtual Model::CreateVerifiedAccessInstanceOutcome CreateVerifiedAccessInstance(const Model::CreateVerifiedAccessInstanceRequest& request) const; /** * A Callable wrapper for CreateVerifiedAccessInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVerifiedAccessInstanceOutcomeCallable CreateVerifiedAccessInstanceCallable(const CreateVerifiedAccessInstanceRequestT& request) const { return SubmitCallable(&EC2Client::CreateVerifiedAccessInstance, request); } /** * An Async wrapper for CreateVerifiedAccessInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVerifiedAccessInstanceAsync(const CreateVerifiedAccessInstanceRequestT& request, const CreateVerifiedAccessInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVerifiedAccessInstance, request, handler, context); } /** *

A trust provider is a third-party entity that creates, maintains, and manages * identity information for users and devices. When an application request is made, * the identity information sent by the trust provider is evaluated by Verified * Access before allowing or denying the application request.

See * Also:

AWS * API Reference

*/ virtual Model::CreateVerifiedAccessTrustProviderOutcome CreateVerifiedAccessTrustProvider(const Model::CreateVerifiedAccessTrustProviderRequest& request) const; /** * A Callable wrapper for CreateVerifiedAccessTrustProvider that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVerifiedAccessTrustProviderOutcomeCallable CreateVerifiedAccessTrustProviderCallable(const CreateVerifiedAccessTrustProviderRequestT& request) const { return SubmitCallable(&EC2Client::CreateVerifiedAccessTrustProvider, request); } /** * An Async wrapper for CreateVerifiedAccessTrustProvider that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVerifiedAccessTrustProviderAsync(const CreateVerifiedAccessTrustProviderRequestT& request, const CreateVerifiedAccessTrustProviderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVerifiedAccessTrustProvider, request, handler, context); } /** *

Creates an EBS volume that can be attached to an instance in the same * Availability Zone.

You can create a new empty volume or restore a volume * from an EBS snapshot. Any Amazon Web Services Marketplace product codes from the * snapshot are propagated to the volume.

You can create encrypted volumes. * Encrypted volumes must be attached to instances that support Amazon EBS * encryption. Volumes that are created from encrypted snapshots are also * automatically encrypted. For more information, see Amazon * EBS encryption in the Amazon Elastic Compute Cloud User Guide.

*

You can tag your volumes during creation. For more information, see Tag * your Amazon EC2 resources in the Amazon Elastic Compute Cloud User * Guide.

For more information, see Create * an Amazon EBS volume in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateVolumeOutcome CreateVolume(const Model::CreateVolumeRequest& request) const; /** * A Callable wrapper for CreateVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVolumeOutcomeCallable CreateVolumeCallable(const CreateVolumeRequestT& request) const { return SubmitCallable(&EC2Client::CreateVolume, request); } /** * An Async wrapper for CreateVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVolumeAsync(const CreateVolumeRequestT& request, const CreateVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVolume, request, handler, context); } /** *

Creates a VPC with the specified CIDR blocks. For more information, see IP * addressing for your VPCs and subnets in the Amazon VPC User * Guide.

You can optionally request an IPv6 CIDR block for the VPC. You * can request an Amazon-provided IPv6 CIDR block from Amazon's pool of IPv6 * addresses, or an IPv6 CIDR block from an IPv6 address pool that you provisioned * through bring your own IP addresses (BYOIP).

*

By default, each instance that you launch in the VPC has the default DHCP * options, which include only a default DNS server that we provide * (AmazonProvidedDNS). For more information, see DHCP * option sets in the Amazon VPC User Guide.

You can specify the * instance tenancy value for the VPC when you create it. You can't change this * value for the VPC after you create it. For more information, see Dedicated * Instances in the Amazon EC2 User Guide.

See Also:

AWS API * Reference

*/ virtual Model::CreateVpcOutcome CreateVpc(const Model::CreateVpcRequest& request) const; /** * A Callable wrapper for CreateVpc that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVpcOutcomeCallable CreateVpcCallable(const CreateVpcRequestT& request) const { return SubmitCallable(&EC2Client::CreateVpc, request); } /** * An Async wrapper for CreateVpc that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVpcAsync(const CreateVpcRequestT& request, const CreateVpcResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVpc, request, handler, context); } /** *

Creates a VPC endpoint. A VPC endpoint provides a private connection between * the specified VPC and the specified endpoint service. You can use an endpoint * service provided by Amazon Web Services, an Amazon Web Services Marketplace * Partner, or another Amazon Web Services account. For more information, see the * Amazon Web * Services PrivateLink User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateVpcEndpointOutcome CreateVpcEndpoint(const Model::CreateVpcEndpointRequest& request) const; /** * A Callable wrapper for CreateVpcEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVpcEndpointOutcomeCallable CreateVpcEndpointCallable(const CreateVpcEndpointRequestT& request) const { return SubmitCallable(&EC2Client::CreateVpcEndpoint, request); } /** * An Async wrapper for CreateVpcEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVpcEndpointAsync(const CreateVpcEndpointRequestT& request, const CreateVpcEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVpcEndpoint, request, handler, context); } /** *

Creates a connection notification for a specified VPC endpoint or VPC * endpoint service. A connection notification notifies you of specific endpoint * events. You must create an SNS topic to receive notifications. For more * information, see Create a * Topic in the Amazon Simple Notification Service Developer Guide.

*

You can create a connection notification for interface endpoints * only.

See Also:

AWS * API Reference

*/ virtual Model::CreateVpcEndpointConnectionNotificationOutcome CreateVpcEndpointConnectionNotification(const Model::CreateVpcEndpointConnectionNotificationRequest& request) const; /** * A Callable wrapper for CreateVpcEndpointConnectionNotification that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVpcEndpointConnectionNotificationOutcomeCallable CreateVpcEndpointConnectionNotificationCallable(const CreateVpcEndpointConnectionNotificationRequestT& request) const { return SubmitCallable(&EC2Client::CreateVpcEndpointConnectionNotification, request); } /** * An Async wrapper for CreateVpcEndpointConnectionNotification that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVpcEndpointConnectionNotificationAsync(const CreateVpcEndpointConnectionNotificationRequestT& request, const CreateVpcEndpointConnectionNotificationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVpcEndpointConnectionNotification, request, handler, context); } /** *

Creates a VPC endpoint service to which service consumers (Amazon Web * Services accounts, users, and IAM roles) can connect.

Before you create * an endpoint service, you must create one of the following for your service:

*

If you set the private DNS name, you * must prove that you own the private DNS domain name.

For more * information, see the Amazon Web Services * PrivateLink Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateVpcEndpointServiceConfigurationOutcome CreateVpcEndpointServiceConfiguration(const Model::CreateVpcEndpointServiceConfigurationRequest& request) const; /** * A Callable wrapper for CreateVpcEndpointServiceConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVpcEndpointServiceConfigurationOutcomeCallable CreateVpcEndpointServiceConfigurationCallable(const CreateVpcEndpointServiceConfigurationRequestT& request) const { return SubmitCallable(&EC2Client::CreateVpcEndpointServiceConfiguration, request); } /** * An Async wrapper for CreateVpcEndpointServiceConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVpcEndpointServiceConfigurationAsync(const CreateVpcEndpointServiceConfigurationRequestT& request, const CreateVpcEndpointServiceConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVpcEndpointServiceConfiguration, request, handler, context); } /** *

Requests a VPC peering connection between two VPCs: a requester VPC that you * own and an accepter VPC with which to create the connection. The accepter VPC * can belong to another Amazon Web Services account and can be in a different * Region to the requester VPC. The requester VPC and accepter VPC cannot have * overlapping CIDR blocks.

Limitations and rules apply to a VPC * peering connection. For more information, see the limitations * section in the VPC Peering Guide.

The owner of the * accepter VPC must accept the peering request to activate the peering connection. * The VPC peering connection request expires after 7 days, after which it cannot * be accepted or rejected.

If you create a VPC peering connection request * between VPCs with overlapping CIDR blocks, the VPC peering connection has a * status of failed.

See Also:

AWS * API Reference

*/ virtual Model::CreateVpcPeeringConnectionOutcome CreateVpcPeeringConnection(const Model::CreateVpcPeeringConnectionRequest& request) const; /** * A Callable wrapper for CreateVpcPeeringConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVpcPeeringConnectionOutcomeCallable CreateVpcPeeringConnectionCallable(const CreateVpcPeeringConnectionRequestT& request) const { return SubmitCallable(&EC2Client::CreateVpcPeeringConnection, request); } /** * An Async wrapper for CreateVpcPeeringConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVpcPeeringConnectionAsync(const CreateVpcPeeringConnectionRequestT& request, const CreateVpcPeeringConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVpcPeeringConnection, request, handler, context); } /** *

Creates a VPN connection between an existing virtual private gateway or * transit gateway and a customer gateway. The supported connection type is * ipsec.1.

The response includes information that you need to * give to your network administrator to configure your customer gateway.

*

We strongly recommend that you use HTTPS when calling this * operation because the response contains sensitive cryptographic information for * configuring your customer gateway device.

If you decide to * shut down your VPN connection for any reason and later create a new VPN * connection, you must reconfigure your customer gateway with the new information * returned from this call.

This is an idempotent operation. If you perform * the operation more than once, Amazon EC2 doesn't return an error.

For * more information, see Amazon Web * Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateVpnConnectionOutcome CreateVpnConnection(const Model::CreateVpnConnectionRequest& request) const; /** * A Callable wrapper for CreateVpnConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVpnConnectionOutcomeCallable CreateVpnConnectionCallable(const CreateVpnConnectionRequestT& request) const { return SubmitCallable(&EC2Client::CreateVpnConnection, request); } /** * An Async wrapper for CreateVpnConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVpnConnectionAsync(const CreateVpnConnectionRequestT& request, const CreateVpnConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVpnConnection, request, handler, context); } /** *

Creates a static route associated with a VPN connection between an existing * virtual private gateway and a VPN customer gateway. The static route allows * traffic to be routed from the virtual private gateway to the VPN customer * gateway.

For more information, see Amazon Web * Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateVpnConnectionRouteOutcome CreateVpnConnectionRoute(const Model::CreateVpnConnectionRouteRequest& request) const; /** * A Callable wrapper for CreateVpnConnectionRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVpnConnectionRouteOutcomeCallable CreateVpnConnectionRouteCallable(const CreateVpnConnectionRouteRequestT& request) const { return SubmitCallable(&EC2Client::CreateVpnConnectionRoute, request); } /** * An Async wrapper for CreateVpnConnectionRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVpnConnectionRouteAsync(const CreateVpnConnectionRouteRequestT& request, const CreateVpnConnectionRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVpnConnectionRoute, request, handler, context); } /** *

Creates a virtual private gateway. A virtual private gateway is the endpoint * on the VPC side of your VPN connection. You can create a virtual private gateway * before creating the VPC itself.

For more information, see Amazon Web * Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateVpnGatewayOutcome CreateVpnGateway(const Model::CreateVpnGatewayRequest& request) const; /** * A Callable wrapper for CreateVpnGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVpnGatewayOutcomeCallable CreateVpnGatewayCallable(const CreateVpnGatewayRequestT& request) const { return SubmitCallable(&EC2Client::CreateVpnGateway, request); } /** * An Async wrapper for CreateVpnGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVpnGatewayAsync(const CreateVpnGatewayRequestT& request, const CreateVpnGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::CreateVpnGateway, request, handler, context); } /** *

Deletes a carrier gateway.

If you do not delete the route * that contains the carrier gateway as the Target, the route is a blackhole route. * For information about how to delete a route, see DeleteRoute.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteCarrierGatewayOutcome DeleteCarrierGateway(const Model::DeleteCarrierGatewayRequest& request) const; /** * A Callable wrapper for DeleteCarrierGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCarrierGatewayOutcomeCallable DeleteCarrierGatewayCallable(const DeleteCarrierGatewayRequestT& request) const { return SubmitCallable(&EC2Client::DeleteCarrierGateway, request); } /** * An Async wrapper for DeleteCarrierGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCarrierGatewayAsync(const DeleteCarrierGatewayRequestT& request, const DeleteCarrierGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteCarrierGateway, request, handler, context); } /** *

Deletes the specified Client VPN endpoint. You must disassociate all target * networks before you can delete a Client VPN endpoint.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteClientVpnEndpointOutcome DeleteClientVpnEndpoint(const Model::DeleteClientVpnEndpointRequest& request) const; /** * A Callable wrapper for DeleteClientVpnEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteClientVpnEndpointOutcomeCallable DeleteClientVpnEndpointCallable(const DeleteClientVpnEndpointRequestT& request) const { return SubmitCallable(&EC2Client::DeleteClientVpnEndpoint, request); } /** * An Async wrapper for DeleteClientVpnEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteClientVpnEndpointAsync(const DeleteClientVpnEndpointRequestT& request, const DeleteClientVpnEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteClientVpnEndpoint, request, handler, context); } /** *

Deletes a route from a Client VPN endpoint. You can only delete routes that * you manually added using the CreateClientVpnRoute action. You cannot * delete routes that were automatically added when associating a subnet. To remove * routes that have been automatically added, disassociate the target subnet from * the Client VPN endpoint.

See Also:

AWS * API Reference

*/ virtual Model::DeleteClientVpnRouteOutcome DeleteClientVpnRoute(const Model::DeleteClientVpnRouteRequest& request) const; /** * A Callable wrapper for DeleteClientVpnRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteClientVpnRouteOutcomeCallable DeleteClientVpnRouteCallable(const DeleteClientVpnRouteRequestT& request) const { return SubmitCallable(&EC2Client::DeleteClientVpnRoute, request); } /** * An Async wrapper for DeleteClientVpnRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteClientVpnRouteAsync(const DeleteClientVpnRouteRequestT& request, const DeleteClientVpnRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteClientVpnRoute, request, handler, context); } /** *

Deletes a range of customer-owned IP addresses.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteCoipCidrOutcome DeleteCoipCidr(const Model::DeleteCoipCidrRequest& request) const; /** * A Callable wrapper for DeleteCoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCoipCidrOutcomeCallable DeleteCoipCidrCallable(const DeleteCoipCidrRequestT& request) const { return SubmitCallable(&EC2Client::DeleteCoipCidr, request); } /** * An Async wrapper for DeleteCoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCoipCidrAsync(const DeleteCoipCidrRequestT& request, const DeleteCoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteCoipCidr, request, handler, context); } /** *

Deletes a pool of customer-owned IP (CoIP) addresses.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteCoipPoolOutcome DeleteCoipPool(const Model::DeleteCoipPoolRequest& request) const; /** * A Callable wrapper for DeleteCoipPool that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCoipPoolOutcomeCallable DeleteCoipPoolCallable(const DeleteCoipPoolRequestT& request) const { return SubmitCallable(&EC2Client::DeleteCoipPool, request); } /** * An Async wrapper for DeleteCoipPool that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCoipPoolAsync(const DeleteCoipPoolRequestT& request, const DeleteCoipPoolResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteCoipPool, request, handler, context); } /** *

Deletes the specified customer gateway. You must delete the VPN connection * before you can delete the customer gateway.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCustomerGatewayOutcome DeleteCustomerGateway(const Model::DeleteCustomerGatewayRequest& request) const; /** * A Callable wrapper for DeleteCustomerGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCustomerGatewayOutcomeCallable DeleteCustomerGatewayCallable(const DeleteCustomerGatewayRequestT& request) const { return SubmitCallable(&EC2Client::DeleteCustomerGateway, request); } /** * An Async wrapper for DeleteCustomerGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCustomerGatewayAsync(const DeleteCustomerGatewayRequestT& request, const DeleteCustomerGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteCustomerGateway, request, handler, context); } /** *

Deletes the specified set of DHCP options. You must disassociate the set of * DHCP options before you can delete it. You can disassociate the set of DHCP * options by associating either a new set of options or the default set of options * with the VPC.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDhcpOptionsOutcome DeleteDhcpOptions(const Model::DeleteDhcpOptionsRequest& request) const; /** * A Callable wrapper for DeleteDhcpOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDhcpOptionsOutcomeCallable DeleteDhcpOptionsCallable(const DeleteDhcpOptionsRequestT& request) const { return SubmitCallable(&EC2Client::DeleteDhcpOptions, request); } /** * An Async wrapper for DeleteDhcpOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDhcpOptionsAsync(const DeleteDhcpOptionsRequestT& request, const DeleteDhcpOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteDhcpOptions, request, handler, context); } /** *

Deletes an egress-only internet gateway.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEgressOnlyInternetGatewayOutcome DeleteEgressOnlyInternetGateway(const Model::DeleteEgressOnlyInternetGatewayRequest& request) const; /** * A Callable wrapper for DeleteEgressOnlyInternetGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEgressOnlyInternetGatewayOutcomeCallable DeleteEgressOnlyInternetGatewayCallable(const DeleteEgressOnlyInternetGatewayRequestT& request) const { return SubmitCallable(&EC2Client::DeleteEgressOnlyInternetGateway, request); } /** * An Async wrapper for DeleteEgressOnlyInternetGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEgressOnlyInternetGatewayAsync(const DeleteEgressOnlyInternetGatewayRequestT& request, const DeleteEgressOnlyInternetGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteEgressOnlyInternetGateway, request, handler, context); } /** *

Deletes the specified EC2 Fleets.

After you delete an EC2 Fleet, it * launches no new instances.

You must also specify whether a deleted EC2 * Fleet should terminate its instances. If you choose to terminate the instances, * the EC2 Fleet enters the deleted_terminating state. Otherwise, the * EC2 Fleet enters the deleted_running state, and the instances * continue to run until they are interrupted or you terminate them manually.

*

For instant fleets, EC2 Fleet must terminate the instances when * the fleet is deleted. A deleted instant fleet with running * instances is not supported.

Restrictions

    *

  • You can delete up to 25 instant fleets in a single request. * If you exceed this number, no instant fleets are deleted and an * error is returned. There is no restriction on the number of fleets of type * maintain or request that can be deleted in a single * request.

  • Up to 1000 instances can be terminated in a single * request to delete instant fleets.

For more * information, see Delete * an EC2 Fleet in the Amazon EC2 User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteFleetsOutcome DeleteFleets(const Model::DeleteFleetsRequest& request) const; /** * A Callable wrapper for DeleteFleets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFleetsOutcomeCallable DeleteFleetsCallable(const DeleteFleetsRequestT& request) const { return SubmitCallable(&EC2Client::DeleteFleets, request); } /** * An Async wrapper for DeleteFleets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFleetsAsync(const DeleteFleetsRequestT& request, const DeleteFleetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteFleets, request, handler, context); } /** *

Deletes one or more flow logs.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFlowLogsOutcome DeleteFlowLogs(const Model::DeleteFlowLogsRequest& request) const; /** * A Callable wrapper for DeleteFlowLogs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFlowLogsOutcomeCallable DeleteFlowLogsCallable(const DeleteFlowLogsRequestT& request) const { return SubmitCallable(&EC2Client::DeleteFlowLogs, request); } /** * An Async wrapper for DeleteFlowLogs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFlowLogsAsync(const DeleteFlowLogsRequestT& request, const DeleteFlowLogsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteFlowLogs, request, handler, context); } /** *

Deletes the specified Amazon FPGA Image (AFI).

See Also:

AWS * API Reference

*/ virtual Model::DeleteFpgaImageOutcome DeleteFpgaImage(const Model::DeleteFpgaImageRequest& request) const; /** * A Callable wrapper for DeleteFpgaImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFpgaImageOutcomeCallable DeleteFpgaImageCallable(const DeleteFpgaImageRequestT& request) const { return SubmitCallable(&EC2Client::DeleteFpgaImage, request); } /** * An Async wrapper for DeleteFpgaImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFpgaImageAsync(const DeleteFpgaImageRequestT& request, const DeleteFpgaImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteFpgaImage, request, handler, context); } /** *

Deletes the specified EC2 Instance Connect Endpoint.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteInstanceConnectEndpointOutcome DeleteInstanceConnectEndpoint(const Model::DeleteInstanceConnectEndpointRequest& request) const; /** * A Callable wrapper for DeleteInstanceConnectEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInstanceConnectEndpointOutcomeCallable DeleteInstanceConnectEndpointCallable(const DeleteInstanceConnectEndpointRequestT& request) const { return SubmitCallable(&EC2Client::DeleteInstanceConnectEndpoint, request); } /** * An Async wrapper for DeleteInstanceConnectEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInstanceConnectEndpointAsync(const DeleteInstanceConnectEndpointRequestT& request, const DeleteInstanceConnectEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteInstanceConnectEndpoint, request, handler, context); } /** *

Deletes the specified event window.

For more information, see Define * event windows for scheduled events in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInstanceEventWindowOutcome DeleteInstanceEventWindow(const Model::DeleteInstanceEventWindowRequest& request) const; /** * A Callable wrapper for DeleteInstanceEventWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInstanceEventWindowOutcomeCallable DeleteInstanceEventWindowCallable(const DeleteInstanceEventWindowRequestT& request) const { return SubmitCallable(&EC2Client::DeleteInstanceEventWindow, request); } /** * An Async wrapper for DeleteInstanceEventWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInstanceEventWindowAsync(const DeleteInstanceEventWindowRequestT& request, const DeleteInstanceEventWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteInstanceEventWindow, request, handler, context); } /** *

Deletes the specified internet gateway. You must detach the internet gateway * from the VPC before you can delete it.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInternetGatewayOutcome DeleteInternetGateway(const Model::DeleteInternetGatewayRequest& request) const; /** * A Callable wrapper for DeleteInternetGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInternetGatewayOutcomeCallable DeleteInternetGatewayCallable(const DeleteInternetGatewayRequestT& request) const { return SubmitCallable(&EC2Client::DeleteInternetGateway, request); } /** * An Async wrapper for DeleteInternetGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInternetGatewayAsync(const DeleteInternetGatewayRequestT& request, const DeleteInternetGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteInternetGateway, request, handler, context); } /** *

Delete an IPAM. Deleting an IPAM removes all monitored data associated with * the IPAM including the historical data for CIDRs.

For more information, * see Delete an * IPAM in the Amazon VPC IPAM User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteIpamOutcome DeleteIpam(const Model::DeleteIpamRequest& request) const; /** * A Callable wrapper for DeleteIpam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIpamOutcomeCallable DeleteIpamCallable(const DeleteIpamRequestT& request) const { return SubmitCallable(&EC2Client::DeleteIpam, request); } /** * An Async wrapper for DeleteIpam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIpamAsync(const DeleteIpamRequestT& request, const DeleteIpamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteIpam, request, handler, context); } /** *

Delete an IPAM pool.

You cannot delete an IPAM pool if there * are allocations in it or CIDRs provisioned to it. To release allocations, see ReleaseIpamPoolAllocation. * To deprovision pool CIDRs, see DeprovisionIpamPoolCidr.

*

For more information, see Delete * a pool in the Amazon VPC IPAM User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteIpamPoolOutcome DeleteIpamPool(const Model::DeleteIpamPoolRequest& request) const; /** * A Callable wrapper for DeleteIpamPool that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIpamPoolOutcomeCallable DeleteIpamPoolCallable(const DeleteIpamPoolRequestT& request) const { return SubmitCallable(&EC2Client::DeleteIpamPool, request); } /** * An Async wrapper for DeleteIpamPool that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIpamPoolAsync(const DeleteIpamPoolRequestT& request, const DeleteIpamPoolResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteIpamPool, request, handler, context); } /** *

Deletes an IPAM resource discovery. A resource discovery is an IPAM component * that enables IPAM to manage and monitor resources that belong to the owning * account.

See Also:

AWS * API Reference

*/ virtual Model::DeleteIpamResourceDiscoveryOutcome DeleteIpamResourceDiscovery(const Model::DeleteIpamResourceDiscoveryRequest& request) const; /** * A Callable wrapper for DeleteIpamResourceDiscovery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIpamResourceDiscoveryOutcomeCallable DeleteIpamResourceDiscoveryCallable(const DeleteIpamResourceDiscoveryRequestT& request) const { return SubmitCallable(&EC2Client::DeleteIpamResourceDiscovery, request); } /** * An Async wrapper for DeleteIpamResourceDiscovery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIpamResourceDiscoveryAsync(const DeleteIpamResourceDiscoveryRequestT& request, const DeleteIpamResourceDiscoveryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteIpamResourceDiscovery, request, handler, context); } /** *

Delete the scope for an IPAM. You cannot delete the default scopes.

*

For more information, see Delete * a scope in the Amazon VPC IPAM User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteIpamScopeOutcome DeleteIpamScope(const Model::DeleteIpamScopeRequest& request) const; /** * A Callable wrapper for DeleteIpamScope that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIpamScopeOutcomeCallable DeleteIpamScopeCallable(const DeleteIpamScopeRequestT& request) const { return SubmitCallable(&EC2Client::DeleteIpamScope, request); } /** * An Async wrapper for DeleteIpamScope that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIpamScopeAsync(const DeleteIpamScopeRequestT& request, const DeleteIpamScopeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteIpamScope, request, handler, context); } /** *

Deletes the specified key pair, by removing the public key from Amazon * EC2.

See Also:

AWS * API Reference

*/ virtual Model::DeleteKeyPairOutcome DeleteKeyPair(const Model::DeleteKeyPairRequest& request) const; /** * A Callable wrapper for DeleteKeyPair that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteKeyPairOutcomeCallable DeleteKeyPairCallable(const DeleteKeyPairRequestT& request) const { return SubmitCallable(&EC2Client::DeleteKeyPair, request); } /** * An Async wrapper for DeleteKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteKeyPairAsync(const DeleteKeyPairRequestT& request, const DeleteKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteKeyPair, request, handler, context); } /** *

Deletes a launch template. Deleting a launch template deletes all of its * versions.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLaunchTemplateOutcome DeleteLaunchTemplate(const Model::DeleteLaunchTemplateRequest& request) const; /** * A Callable wrapper for DeleteLaunchTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLaunchTemplateOutcomeCallable DeleteLaunchTemplateCallable(const DeleteLaunchTemplateRequestT& request) const { return SubmitCallable(&EC2Client::DeleteLaunchTemplate, request); } /** * An Async wrapper for DeleteLaunchTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLaunchTemplateAsync(const DeleteLaunchTemplateRequestT& request, const DeleteLaunchTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteLaunchTemplate, request, handler, context); } /** *

Deletes one or more versions of a launch template. You cannot delete the * default version of a launch template; you must first assign a different version * as the default. If the default version is the only version for the launch * template, you must delete the entire launch template using * DeleteLaunchTemplate.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLaunchTemplateVersionsOutcome DeleteLaunchTemplateVersions(const Model::DeleteLaunchTemplateVersionsRequest& request) const; /** * A Callable wrapper for DeleteLaunchTemplateVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLaunchTemplateVersionsOutcomeCallable DeleteLaunchTemplateVersionsCallable(const DeleteLaunchTemplateVersionsRequestT& request) const { return SubmitCallable(&EC2Client::DeleteLaunchTemplateVersions, request); } /** * An Async wrapper for DeleteLaunchTemplateVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLaunchTemplateVersionsAsync(const DeleteLaunchTemplateVersionsRequestT& request, const DeleteLaunchTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteLaunchTemplateVersions, request, handler, context); } /** *

Deletes the specified route from the specified local gateway route * table.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLocalGatewayRouteOutcome DeleteLocalGatewayRoute(const Model::DeleteLocalGatewayRouteRequest& request) const; /** * A Callable wrapper for DeleteLocalGatewayRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLocalGatewayRouteOutcomeCallable DeleteLocalGatewayRouteCallable(const DeleteLocalGatewayRouteRequestT& request) const { return SubmitCallable(&EC2Client::DeleteLocalGatewayRoute, request); } /** * An Async wrapper for DeleteLocalGatewayRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLocalGatewayRouteAsync(const DeleteLocalGatewayRouteRequestT& request, const DeleteLocalGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteLocalGatewayRoute, request, handler, context); } /** *

Deletes a local gateway route table.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLocalGatewayRouteTableOutcome DeleteLocalGatewayRouteTable(const Model::DeleteLocalGatewayRouteTableRequest& request) const; /** * A Callable wrapper for DeleteLocalGatewayRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLocalGatewayRouteTableOutcomeCallable DeleteLocalGatewayRouteTableCallable(const DeleteLocalGatewayRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::DeleteLocalGatewayRouteTable, request); } /** * An Async wrapper for DeleteLocalGatewayRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLocalGatewayRouteTableAsync(const DeleteLocalGatewayRouteTableRequestT& request, const DeleteLocalGatewayRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteLocalGatewayRouteTable, request, handler, context); } /** *

Deletes a local gateway route table virtual interface group association. *

See Also:

AWS * API Reference

*/ virtual Model::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutcome DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(const Model::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest& request) const; /** * A Callable wrapper for DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutcomeCallable DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationCallable(const DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT& request) const { return SubmitCallable(&EC2Client::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation, request); } /** * An Async wrapper for DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationAsync(const DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT& request, const DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation, request, handler, context); } /** *

Deletes the specified association between a VPC and local gateway route * table.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLocalGatewayRouteTableVpcAssociationOutcome DeleteLocalGatewayRouteTableVpcAssociation(const Model::DeleteLocalGatewayRouteTableVpcAssociationRequest& request) const; /** * A Callable wrapper for DeleteLocalGatewayRouteTableVpcAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLocalGatewayRouteTableVpcAssociationOutcomeCallable DeleteLocalGatewayRouteTableVpcAssociationCallable(const DeleteLocalGatewayRouteTableVpcAssociationRequestT& request) const { return SubmitCallable(&EC2Client::DeleteLocalGatewayRouteTableVpcAssociation, request); } /** * An Async wrapper for DeleteLocalGatewayRouteTableVpcAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLocalGatewayRouteTableVpcAssociationAsync(const DeleteLocalGatewayRouteTableVpcAssociationRequestT& request, const DeleteLocalGatewayRouteTableVpcAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteLocalGatewayRouteTableVpcAssociation, request, handler, context); } /** *

Deletes the specified managed prefix list. You must first remove all * references to the prefix list in your resources.

See Also:

AWS * API Reference

*/ virtual Model::DeleteManagedPrefixListOutcome DeleteManagedPrefixList(const Model::DeleteManagedPrefixListRequest& request) const; /** * A Callable wrapper for DeleteManagedPrefixList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteManagedPrefixListOutcomeCallable DeleteManagedPrefixListCallable(const DeleteManagedPrefixListRequestT& request) const { return SubmitCallable(&EC2Client::DeleteManagedPrefixList, request); } /** * An Async wrapper for DeleteManagedPrefixList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteManagedPrefixListAsync(const DeleteManagedPrefixListRequestT& request, const DeleteManagedPrefixListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteManagedPrefixList, request, handler, context); } /** *

Deletes the specified NAT gateway. Deleting a public NAT gateway * disassociates its Elastic IP address, but does not release the address from your * account. Deleting a NAT gateway does not delete any NAT gateway routes in your * route tables.

See Also:

AWS * API Reference

*/ virtual Model::DeleteNatGatewayOutcome DeleteNatGateway(const Model::DeleteNatGatewayRequest& request) const; /** * A Callable wrapper for DeleteNatGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNatGatewayOutcomeCallable DeleteNatGatewayCallable(const DeleteNatGatewayRequestT& request) const { return SubmitCallable(&EC2Client::DeleteNatGateway, request); } /** * An Async wrapper for DeleteNatGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNatGatewayAsync(const DeleteNatGatewayRequestT& request, const DeleteNatGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteNatGateway, request, handler, context); } /** *

Deletes the specified network ACL. You can't delete the ACL if it's * associated with any subnets. You can't delete the default network * ACL.

See Also:

AWS * API Reference

*/ virtual Model::DeleteNetworkAclOutcome DeleteNetworkAcl(const Model::DeleteNetworkAclRequest& request) const; /** * A Callable wrapper for DeleteNetworkAcl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNetworkAclOutcomeCallable DeleteNetworkAclCallable(const DeleteNetworkAclRequestT& request) const { return SubmitCallable(&EC2Client::DeleteNetworkAcl, request); } /** * An Async wrapper for DeleteNetworkAcl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNetworkAclAsync(const DeleteNetworkAclRequestT& request, const DeleteNetworkAclResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteNetworkAcl, request, handler, context); } /** *

Deletes the specified ingress or egress entry (rule) from the specified * network ACL.

See Also:

AWS * API Reference

*/ virtual Model::DeleteNetworkAclEntryOutcome DeleteNetworkAclEntry(const Model::DeleteNetworkAclEntryRequest& request) const; /** * A Callable wrapper for DeleteNetworkAclEntry that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNetworkAclEntryOutcomeCallable DeleteNetworkAclEntryCallable(const DeleteNetworkAclEntryRequestT& request) const { return SubmitCallable(&EC2Client::DeleteNetworkAclEntry, request); } /** * An Async wrapper for DeleteNetworkAclEntry that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNetworkAclEntryAsync(const DeleteNetworkAclEntryRequestT& request, const DeleteNetworkAclEntryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteNetworkAclEntry, request, handler, context); } /** *

Deletes the specified Network Access Scope.

See Also:

AWS * API Reference

*/ virtual Model::DeleteNetworkInsightsAccessScopeOutcome DeleteNetworkInsightsAccessScope(const Model::DeleteNetworkInsightsAccessScopeRequest& request) const; /** * A Callable wrapper for DeleteNetworkInsightsAccessScope that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNetworkInsightsAccessScopeOutcomeCallable DeleteNetworkInsightsAccessScopeCallable(const DeleteNetworkInsightsAccessScopeRequestT& request) const { return SubmitCallable(&EC2Client::DeleteNetworkInsightsAccessScope, request); } /** * An Async wrapper for DeleteNetworkInsightsAccessScope that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNetworkInsightsAccessScopeAsync(const DeleteNetworkInsightsAccessScopeRequestT& request, const DeleteNetworkInsightsAccessScopeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteNetworkInsightsAccessScope, request, handler, context); } /** *

Deletes the specified Network Access Scope analysis.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteNetworkInsightsAccessScopeAnalysisOutcome DeleteNetworkInsightsAccessScopeAnalysis(const Model::DeleteNetworkInsightsAccessScopeAnalysisRequest& request) const; /** * A Callable wrapper for DeleteNetworkInsightsAccessScopeAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNetworkInsightsAccessScopeAnalysisOutcomeCallable DeleteNetworkInsightsAccessScopeAnalysisCallable(const DeleteNetworkInsightsAccessScopeAnalysisRequestT& request) const { return SubmitCallable(&EC2Client::DeleteNetworkInsightsAccessScopeAnalysis, request); } /** * An Async wrapper for DeleteNetworkInsightsAccessScopeAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNetworkInsightsAccessScopeAnalysisAsync(const DeleteNetworkInsightsAccessScopeAnalysisRequestT& request, const DeleteNetworkInsightsAccessScopeAnalysisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteNetworkInsightsAccessScopeAnalysis, request, handler, context); } /** *

Deletes the specified network insights analysis.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteNetworkInsightsAnalysisOutcome DeleteNetworkInsightsAnalysis(const Model::DeleteNetworkInsightsAnalysisRequest& request) const; /** * A Callable wrapper for DeleteNetworkInsightsAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNetworkInsightsAnalysisOutcomeCallable DeleteNetworkInsightsAnalysisCallable(const DeleteNetworkInsightsAnalysisRequestT& request) const { return SubmitCallable(&EC2Client::DeleteNetworkInsightsAnalysis, request); } /** * An Async wrapper for DeleteNetworkInsightsAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNetworkInsightsAnalysisAsync(const DeleteNetworkInsightsAnalysisRequestT& request, const DeleteNetworkInsightsAnalysisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteNetworkInsightsAnalysis, request, handler, context); } /** *

Deletes the specified path.

See Also:

AWS * API Reference

*/ virtual Model::DeleteNetworkInsightsPathOutcome DeleteNetworkInsightsPath(const Model::DeleteNetworkInsightsPathRequest& request) const; /** * A Callable wrapper for DeleteNetworkInsightsPath that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNetworkInsightsPathOutcomeCallable DeleteNetworkInsightsPathCallable(const DeleteNetworkInsightsPathRequestT& request) const { return SubmitCallable(&EC2Client::DeleteNetworkInsightsPath, request); } /** * An Async wrapper for DeleteNetworkInsightsPath that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNetworkInsightsPathAsync(const DeleteNetworkInsightsPathRequestT& request, const DeleteNetworkInsightsPathResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteNetworkInsightsPath, request, handler, context); } /** *

Deletes the specified network interface. You must detach the network * interface before you can delete it.

See Also:

AWS * API Reference

*/ virtual Model::DeleteNetworkInterfaceOutcome DeleteNetworkInterface(const Model::DeleteNetworkInterfaceRequest& request) const; /** * A Callable wrapper for DeleteNetworkInterface that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNetworkInterfaceOutcomeCallable DeleteNetworkInterfaceCallable(const DeleteNetworkInterfaceRequestT& request) const { return SubmitCallable(&EC2Client::DeleteNetworkInterface, request); } /** * An Async wrapper for DeleteNetworkInterface that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNetworkInterfaceAsync(const DeleteNetworkInterfaceRequestT& request, const DeleteNetworkInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteNetworkInterface, request, handler, context); } /** *

Deletes a permission for a network interface. By default, you cannot delete * the permission if the account for which you're removing the permission has * attached the network interface to an instance. However, you can force delete the * permission, regardless of any attachment.

See Also:

AWS * API Reference

*/ virtual Model::DeleteNetworkInterfacePermissionOutcome DeleteNetworkInterfacePermission(const Model::DeleteNetworkInterfacePermissionRequest& request) const; /** * A Callable wrapper for DeleteNetworkInterfacePermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNetworkInterfacePermissionOutcomeCallable DeleteNetworkInterfacePermissionCallable(const DeleteNetworkInterfacePermissionRequestT& request) const { return SubmitCallable(&EC2Client::DeleteNetworkInterfacePermission, request); } /** * An Async wrapper for DeleteNetworkInterfacePermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNetworkInterfacePermissionAsync(const DeleteNetworkInterfacePermissionRequestT& request, const DeleteNetworkInterfacePermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteNetworkInterfacePermission, request, handler, context); } /** *

Deletes the specified placement group. You must terminate all instances in * the placement group before you can delete the placement group. For more * information, see Placement * groups in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeletePlacementGroupOutcome DeletePlacementGroup(const Model::DeletePlacementGroupRequest& request) const; /** * A Callable wrapper for DeletePlacementGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePlacementGroupOutcomeCallable DeletePlacementGroupCallable(const DeletePlacementGroupRequestT& request) const { return SubmitCallable(&EC2Client::DeletePlacementGroup, request); } /** * An Async wrapper for DeletePlacementGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePlacementGroupAsync(const DeletePlacementGroupRequestT& request, const DeletePlacementGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeletePlacementGroup, request, handler, context); } /** *

Delete a public IPv4 pool. A public IPv4 pool is an EC2 IP address pool * required for the public IPv4 CIDRs that you own and bring to Amazon Web Services * to manage with IPAM. IPv6 addresses you bring to Amazon Web Services, however, * use IPAM pools only.

See Also:

AWS * API Reference

*/ virtual Model::DeletePublicIpv4PoolOutcome DeletePublicIpv4Pool(const Model::DeletePublicIpv4PoolRequest& request) const; /** * A Callable wrapper for DeletePublicIpv4Pool that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePublicIpv4PoolOutcomeCallable DeletePublicIpv4PoolCallable(const DeletePublicIpv4PoolRequestT& request) const { return SubmitCallable(&EC2Client::DeletePublicIpv4Pool, request); } /** * An Async wrapper for DeletePublicIpv4Pool that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePublicIpv4PoolAsync(const DeletePublicIpv4PoolRequestT& request, const DeletePublicIpv4PoolResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeletePublicIpv4Pool, request, handler, context); } /** *

Deletes the queued purchases for the specified Reserved * Instances.

See Also:

AWS * API Reference

*/ virtual Model::DeleteQueuedReservedInstancesOutcome DeleteQueuedReservedInstances(const Model::DeleteQueuedReservedInstancesRequest& request) const; /** * A Callable wrapper for DeleteQueuedReservedInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteQueuedReservedInstancesOutcomeCallable DeleteQueuedReservedInstancesCallable(const DeleteQueuedReservedInstancesRequestT& request) const { return SubmitCallable(&EC2Client::DeleteQueuedReservedInstances, request); } /** * An Async wrapper for DeleteQueuedReservedInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteQueuedReservedInstancesAsync(const DeleteQueuedReservedInstancesRequestT& request, const DeleteQueuedReservedInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteQueuedReservedInstances, request, handler, context); } /** *

Deletes the specified route from the specified route table.

See * Also:

AWS API * Reference

*/ virtual Model::DeleteRouteOutcome DeleteRoute(const Model::DeleteRouteRequest& request) const; /** * A Callable wrapper for DeleteRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRouteOutcomeCallable DeleteRouteCallable(const DeleteRouteRequestT& request) const { return SubmitCallable(&EC2Client::DeleteRoute, request); } /** * An Async wrapper for DeleteRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRouteAsync(const DeleteRouteRequestT& request, const DeleteRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteRoute, request, handler, context); } /** *

Deletes the specified route table. You must disassociate the route table from * any subnets before you can delete it. You can't delete the main route * table.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRouteTableOutcome DeleteRouteTable(const Model::DeleteRouteTableRequest& request) const; /** * A Callable wrapper for DeleteRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRouteTableOutcomeCallable DeleteRouteTableCallable(const DeleteRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::DeleteRouteTable, request); } /** * An Async wrapper for DeleteRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRouteTableAsync(const DeleteRouteTableRequestT& request, const DeleteRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteRouteTable, request, handler, context); } /** *

Deletes a security group.

If you attempt to delete a security group * that is associated with an instance or network interface or is referenced by * another security group, the operation fails with * DependencyViolation.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSecurityGroupOutcome DeleteSecurityGroup(const Model::DeleteSecurityGroupRequest& request) const; /** * A Callable wrapper for DeleteSecurityGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSecurityGroupOutcomeCallable DeleteSecurityGroupCallable(const DeleteSecurityGroupRequestT& request) const { return SubmitCallable(&EC2Client::DeleteSecurityGroup, request); } /** * An Async wrapper for DeleteSecurityGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSecurityGroupAsync(const DeleteSecurityGroupRequestT& request, const DeleteSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteSecurityGroup, request, handler, context); } /** *

Deletes the specified snapshot.

When you make periodic snapshots of a * volume, the snapshots are incremental, and only the blocks on the device that * have changed since your last snapshot are saved in the new snapshot. When you * delete a snapshot, only the data not needed for any other snapshot is removed. * So regardless of which prior snapshots have been deleted, all active snapshots * will have access to all the information needed to restore the volume.

You * cannot delete a snapshot of the root device of an EBS volume used by a * registered AMI. You must first de-register the AMI before you can delete the * snapshot.

For more information, see Delete * an Amazon EBS snapshot in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSnapshotOutcome DeleteSnapshot(const Model::DeleteSnapshotRequest& request) const; /** * A Callable wrapper for DeleteSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSnapshotOutcomeCallable DeleteSnapshotCallable(const DeleteSnapshotRequestT& request) const { return SubmitCallable(&EC2Client::DeleteSnapshot, request); } /** * An Async wrapper for DeleteSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSnapshotAsync(const DeleteSnapshotRequestT& request, const DeleteSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteSnapshot, request, handler, context); } /** *

Deletes the data feed for Spot Instances.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSpotDatafeedSubscriptionOutcome DeleteSpotDatafeedSubscription(const Model::DeleteSpotDatafeedSubscriptionRequest& request) const; /** * A Callable wrapper for DeleteSpotDatafeedSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSpotDatafeedSubscriptionOutcomeCallable DeleteSpotDatafeedSubscriptionCallable(const DeleteSpotDatafeedSubscriptionRequestT& request) const { return SubmitCallable(&EC2Client::DeleteSpotDatafeedSubscription, request); } /** * An Async wrapper for DeleteSpotDatafeedSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSpotDatafeedSubscriptionAsync(const DeleteSpotDatafeedSubscriptionRequestT& request, const DeleteSpotDatafeedSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteSpotDatafeedSubscription, request, handler, context); } /** *

Deletes the specified subnet. You must terminate all running instances in the * subnet before you can delete the subnet.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSubnetOutcome DeleteSubnet(const Model::DeleteSubnetRequest& request) const; /** * A Callable wrapper for DeleteSubnet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSubnetOutcomeCallable DeleteSubnetCallable(const DeleteSubnetRequestT& request) const { return SubmitCallable(&EC2Client::DeleteSubnet, request); } /** * An Async wrapper for DeleteSubnet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSubnetAsync(const DeleteSubnetRequestT& request, const DeleteSubnetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteSubnet, request, handler, context); } /** *

Deletes a subnet CIDR reservation.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSubnetCidrReservationOutcome DeleteSubnetCidrReservation(const Model::DeleteSubnetCidrReservationRequest& request) const; /** * A Callable wrapper for DeleteSubnetCidrReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSubnetCidrReservationOutcomeCallable DeleteSubnetCidrReservationCallable(const DeleteSubnetCidrReservationRequestT& request) const { return SubmitCallable(&EC2Client::DeleteSubnetCidrReservation, request); } /** * An Async wrapper for DeleteSubnetCidrReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSubnetCidrReservationAsync(const DeleteSubnetCidrReservationRequestT& request, const DeleteSubnetCidrReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteSubnetCidrReservation, request, handler, context); } /** *

Deletes the specified set of tags from the specified set of resources.

*

To list the current tags, use DescribeTags. For more information about * tags, see Tag * your Amazon EC2 resources in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS API * Reference

*/ virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const; /** * A Callable wrapper for DeleteTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTags, request); } /** * An Async wrapper for DeleteTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTags, request, handler, context); } /** *

Deletes the specified Traffic Mirror filter.

You cannot delete a * Traffic Mirror filter that is in use by a Traffic Mirror session.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteTrafficMirrorFilterOutcome DeleteTrafficMirrorFilter(const Model::DeleteTrafficMirrorFilterRequest& request) const; /** * A Callable wrapper for DeleteTrafficMirrorFilter that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTrafficMirrorFilterOutcomeCallable DeleteTrafficMirrorFilterCallable(const DeleteTrafficMirrorFilterRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTrafficMirrorFilter, request); } /** * An Async wrapper for DeleteTrafficMirrorFilter that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTrafficMirrorFilterAsync(const DeleteTrafficMirrorFilterRequestT& request, const DeleteTrafficMirrorFilterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTrafficMirrorFilter, request, handler, context); } /** *

Deletes the specified Traffic Mirror rule.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTrafficMirrorFilterRuleOutcome DeleteTrafficMirrorFilterRule(const Model::DeleteTrafficMirrorFilterRuleRequest& request) const; /** * A Callable wrapper for DeleteTrafficMirrorFilterRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTrafficMirrorFilterRuleOutcomeCallable DeleteTrafficMirrorFilterRuleCallable(const DeleteTrafficMirrorFilterRuleRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTrafficMirrorFilterRule, request); } /** * An Async wrapper for DeleteTrafficMirrorFilterRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTrafficMirrorFilterRuleAsync(const DeleteTrafficMirrorFilterRuleRequestT& request, const DeleteTrafficMirrorFilterRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTrafficMirrorFilterRule, request, handler, context); } /** *

Deletes the specified Traffic Mirror session.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTrafficMirrorSessionOutcome DeleteTrafficMirrorSession(const Model::DeleteTrafficMirrorSessionRequest& request) const; /** * A Callable wrapper for DeleteTrafficMirrorSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTrafficMirrorSessionOutcomeCallable DeleteTrafficMirrorSessionCallable(const DeleteTrafficMirrorSessionRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTrafficMirrorSession, request); } /** * An Async wrapper for DeleteTrafficMirrorSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTrafficMirrorSessionAsync(const DeleteTrafficMirrorSessionRequestT& request, const DeleteTrafficMirrorSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTrafficMirrorSession, request, handler, context); } /** *

Deletes the specified Traffic Mirror target.

You cannot delete a * Traffic Mirror target that is in use by a Traffic Mirror session.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteTrafficMirrorTargetOutcome DeleteTrafficMirrorTarget(const Model::DeleteTrafficMirrorTargetRequest& request) const; /** * A Callable wrapper for DeleteTrafficMirrorTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTrafficMirrorTargetOutcomeCallable DeleteTrafficMirrorTargetCallable(const DeleteTrafficMirrorTargetRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTrafficMirrorTarget, request); } /** * An Async wrapper for DeleteTrafficMirrorTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTrafficMirrorTargetAsync(const DeleteTrafficMirrorTargetRequestT& request, const DeleteTrafficMirrorTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTrafficMirrorTarget, request, handler, context); } /** *

Deletes the specified transit gateway.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayOutcome DeleteTransitGateway(const Model::DeleteTransitGatewayRequest& request) const; /** * A Callable wrapper for DeleteTransitGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayOutcomeCallable DeleteTransitGatewayCallable(const DeleteTransitGatewayRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGateway, request); } /** * An Async wrapper for DeleteTransitGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayAsync(const DeleteTransitGatewayRequestT& request, const DeleteTransitGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGateway, request, handler, context); } /** *

Deletes the specified Connect attachment. You must first delete any Connect * peers for the attachment.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayConnectOutcome DeleteTransitGatewayConnect(const Model::DeleteTransitGatewayConnectRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayConnect that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayConnectOutcomeCallable DeleteTransitGatewayConnectCallable(const DeleteTransitGatewayConnectRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayConnect, request); } /** * An Async wrapper for DeleteTransitGatewayConnect that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayConnectAsync(const DeleteTransitGatewayConnectRequestT& request, const DeleteTransitGatewayConnectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayConnect, request, handler, context); } /** *

Deletes the specified Connect peer.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayConnectPeerOutcome DeleteTransitGatewayConnectPeer(const Model::DeleteTransitGatewayConnectPeerRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayConnectPeer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayConnectPeerOutcomeCallable DeleteTransitGatewayConnectPeerCallable(const DeleteTransitGatewayConnectPeerRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayConnectPeer, request); } /** * An Async wrapper for DeleteTransitGatewayConnectPeer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayConnectPeerAsync(const DeleteTransitGatewayConnectPeerRequestT& request, const DeleteTransitGatewayConnectPeerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayConnectPeer, request, handler, context); } /** *

Deletes the specified transit gateway multicast domain.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayMulticastDomainOutcome DeleteTransitGatewayMulticastDomain(const Model::DeleteTransitGatewayMulticastDomainRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayMulticastDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayMulticastDomainOutcomeCallable DeleteTransitGatewayMulticastDomainCallable(const DeleteTransitGatewayMulticastDomainRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayMulticastDomain, request); } /** * An Async wrapper for DeleteTransitGatewayMulticastDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayMulticastDomainAsync(const DeleteTransitGatewayMulticastDomainRequestT& request, const DeleteTransitGatewayMulticastDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayMulticastDomain, request, handler, context); } /** *

Deletes a transit gateway peering attachment.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayPeeringAttachmentOutcome DeleteTransitGatewayPeeringAttachment(const Model::DeleteTransitGatewayPeeringAttachmentRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayPeeringAttachment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayPeeringAttachmentOutcomeCallable DeleteTransitGatewayPeeringAttachmentCallable(const DeleteTransitGatewayPeeringAttachmentRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayPeeringAttachment, request); } /** * An Async wrapper for DeleteTransitGatewayPeeringAttachment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayPeeringAttachmentAsync(const DeleteTransitGatewayPeeringAttachmentRequestT& request, const DeleteTransitGatewayPeeringAttachmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayPeeringAttachment, request, handler, context); } /** *

Deletes the specified transit gateway policy table.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteTransitGatewayPolicyTableOutcome DeleteTransitGatewayPolicyTable(const Model::DeleteTransitGatewayPolicyTableRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayPolicyTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayPolicyTableOutcomeCallable DeleteTransitGatewayPolicyTableCallable(const DeleteTransitGatewayPolicyTableRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayPolicyTable, request); } /** * An Async wrapper for DeleteTransitGatewayPolicyTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayPolicyTableAsync(const DeleteTransitGatewayPolicyTableRequestT& request, const DeleteTransitGatewayPolicyTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayPolicyTable, request, handler, context); } /** *

Deletes a reference (route) to a prefix list in a specified transit gateway * route table.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayPrefixListReferenceOutcome DeleteTransitGatewayPrefixListReference(const Model::DeleteTransitGatewayPrefixListReferenceRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayPrefixListReference that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayPrefixListReferenceOutcomeCallable DeleteTransitGatewayPrefixListReferenceCallable(const DeleteTransitGatewayPrefixListReferenceRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayPrefixListReference, request); } /** * An Async wrapper for DeleteTransitGatewayPrefixListReference that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayPrefixListReferenceAsync(const DeleteTransitGatewayPrefixListReferenceRequestT& request, const DeleteTransitGatewayPrefixListReferenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayPrefixListReference, request, handler, context); } /** *

Deletes the specified route from the specified transit gateway route * table.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayRouteOutcome DeleteTransitGatewayRoute(const Model::DeleteTransitGatewayRouteRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayRouteOutcomeCallable DeleteTransitGatewayRouteCallable(const DeleteTransitGatewayRouteRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayRoute, request); } /** * An Async wrapper for DeleteTransitGatewayRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayRouteAsync(const DeleteTransitGatewayRouteRequestT& request, const DeleteTransitGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayRoute, request, handler, context); } /** *

Deletes the specified transit gateway route table. You must disassociate the * route table from any transit gateway route tables before you can delete * it.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayRouteTableOutcome DeleteTransitGatewayRouteTable(const Model::DeleteTransitGatewayRouteTableRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayRouteTableOutcomeCallable DeleteTransitGatewayRouteTableCallable(const DeleteTransitGatewayRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayRouteTable, request); } /** * An Async wrapper for DeleteTransitGatewayRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayRouteTableAsync(const DeleteTransitGatewayRouteTableRequestT& request, const DeleteTransitGatewayRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayRouteTable, request, handler, context); } /** *

Advertises to the transit gateway that a transit gateway route table is * deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayRouteTableAnnouncementOutcome DeleteTransitGatewayRouteTableAnnouncement(const Model::DeleteTransitGatewayRouteTableAnnouncementRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayRouteTableAnnouncement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayRouteTableAnnouncementOutcomeCallable DeleteTransitGatewayRouteTableAnnouncementCallable(const DeleteTransitGatewayRouteTableAnnouncementRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayRouteTableAnnouncement, request); } /** * An Async wrapper for DeleteTransitGatewayRouteTableAnnouncement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayRouteTableAnnouncementAsync(const DeleteTransitGatewayRouteTableAnnouncementRequestT& request, const DeleteTransitGatewayRouteTableAnnouncementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayRouteTableAnnouncement, request, handler, context); } /** *

Deletes the specified VPC attachment.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTransitGatewayVpcAttachmentOutcome DeleteTransitGatewayVpcAttachment(const Model::DeleteTransitGatewayVpcAttachmentRequest& request) const; /** * A Callable wrapper for DeleteTransitGatewayVpcAttachment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTransitGatewayVpcAttachmentOutcomeCallable DeleteTransitGatewayVpcAttachmentCallable(const DeleteTransitGatewayVpcAttachmentRequestT& request) const { return SubmitCallable(&EC2Client::DeleteTransitGatewayVpcAttachment, request); } /** * An Async wrapper for DeleteTransitGatewayVpcAttachment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTransitGatewayVpcAttachmentAsync(const DeleteTransitGatewayVpcAttachmentRequestT& request, const DeleteTransitGatewayVpcAttachmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteTransitGatewayVpcAttachment, request, handler, context); } /** *

Delete an Amazon Web Services Verified Access endpoint.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteVerifiedAccessEndpointOutcome DeleteVerifiedAccessEndpoint(const Model::DeleteVerifiedAccessEndpointRequest& request) const; /** * A Callable wrapper for DeleteVerifiedAccessEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVerifiedAccessEndpointOutcomeCallable DeleteVerifiedAccessEndpointCallable(const DeleteVerifiedAccessEndpointRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVerifiedAccessEndpoint, request); } /** * An Async wrapper for DeleteVerifiedAccessEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVerifiedAccessEndpointAsync(const DeleteVerifiedAccessEndpointRequestT& request, const DeleteVerifiedAccessEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVerifiedAccessEndpoint, request, handler, context); } /** *

Delete an Amazon Web Services Verified Access group.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteVerifiedAccessGroupOutcome DeleteVerifiedAccessGroup(const Model::DeleteVerifiedAccessGroupRequest& request) const; /** * A Callable wrapper for DeleteVerifiedAccessGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVerifiedAccessGroupOutcomeCallable DeleteVerifiedAccessGroupCallable(const DeleteVerifiedAccessGroupRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVerifiedAccessGroup, request); } /** * An Async wrapper for DeleteVerifiedAccessGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVerifiedAccessGroupAsync(const DeleteVerifiedAccessGroupRequestT& request, const DeleteVerifiedAccessGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVerifiedAccessGroup, request, handler, context); } /** *

Delete an Amazon Web Services Verified Access instance.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteVerifiedAccessInstanceOutcome DeleteVerifiedAccessInstance(const Model::DeleteVerifiedAccessInstanceRequest& request) const; /** * A Callable wrapper for DeleteVerifiedAccessInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVerifiedAccessInstanceOutcomeCallable DeleteVerifiedAccessInstanceCallable(const DeleteVerifiedAccessInstanceRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVerifiedAccessInstance, request); } /** * An Async wrapper for DeleteVerifiedAccessInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVerifiedAccessInstanceAsync(const DeleteVerifiedAccessInstanceRequestT& request, const DeleteVerifiedAccessInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVerifiedAccessInstance, request, handler, context); } /** *

Delete an Amazon Web Services Verified Access trust provider.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteVerifiedAccessTrustProviderOutcome DeleteVerifiedAccessTrustProvider(const Model::DeleteVerifiedAccessTrustProviderRequest& request) const; /** * A Callable wrapper for DeleteVerifiedAccessTrustProvider that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVerifiedAccessTrustProviderOutcomeCallable DeleteVerifiedAccessTrustProviderCallable(const DeleteVerifiedAccessTrustProviderRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVerifiedAccessTrustProvider, request); } /** * An Async wrapper for DeleteVerifiedAccessTrustProvider that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVerifiedAccessTrustProviderAsync(const DeleteVerifiedAccessTrustProviderRequestT& request, const DeleteVerifiedAccessTrustProviderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVerifiedAccessTrustProvider, request, handler, context); } /** *

Deletes the specified EBS volume. The volume must be in the * available state (not attached to an instance).

The volume * can remain in the deleting state for several minutes.

For * more information, see Delete * an Amazon EBS volume in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVolumeOutcome DeleteVolume(const Model::DeleteVolumeRequest& request) const; /** * A Callable wrapper for DeleteVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVolumeOutcomeCallable DeleteVolumeCallable(const DeleteVolumeRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVolume, request); } /** * An Async wrapper for DeleteVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVolumeAsync(const DeleteVolumeRequestT& request, const DeleteVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVolume, request, handler, context); } /** *

Deletes the specified VPC. You must detach or delete all gateways and * resources that are associated with the VPC before you can delete it. For * example, you must terminate all instances running in the VPC, delete all * security groups associated with the VPC (except the default one), delete all * route tables associated with the VPC (except the default one), and so * on.

See Also:

AWS API * Reference

*/ virtual Model::DeleteVpcOutcome DeleteVpc(const Model::DeleteVpcRequest& request) const; /** * A Callable wrapper for DeleteVpc that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVpcOutcomeCallable DeleteVpcCallable(const DeleteVpcRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVpc, request); } /** * An Async wrapper for DeleteVpc that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVpcAsync(const DeleteVpcRequestT& request, const DeleteVpcResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVpc, request, handler, context); } /** *

Deletes the specified VPC endpoint connection notifications.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteVpcEndpointConnectionNotificationsOutcome DeleteVpcEndpointConnectionNotifications(const Model::DeleteVpcEndpointConnectionNotificationsRequest& request) const; /** * A Callable wrapper for DeleteVpcEndpointConnectionNotifications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVpcEndpointConnectionNotificationsOutcomeCallable DeleteVpcEndpointConnectionNotificationsCallable(const DeleteVpcEndpointConnectionNotificationsRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVpcEndpointConnectionNotifications, request); } /** * An Async wrapper for DeleteVpcEndpointConnectionNotifications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVpcEndpointConnectionNotificationsAsync(const DeleteVpcEndpointConnectionNotificationsRequestT& request, const DeleteVpcEndpointConnectionNotificationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVpcEndpointConnectionNotifications, request, handler, context); } /** *

Deletes the specified VPC endpoint service configurations. Before you can * delete an endpoint service configuration, you must reject any * Available or PendingAcceptance interface endpoint * connections that are attached to the service.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVpcEndpointServiceConfigurationsOutcome DeleteVpcEndpointServiceConfigurations(const Model::DeleteVpcEndpointServiceConfigurationsRequest& request) const; /** * A Callable wrapper for DeleteVpcEndpointServiceConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVpcEndpointServiceConfigurationsOutcomeCallable DeleteVpcEndpointServiceConfigurationsCallable(const DeleteVpcEndpointServiceConfigurationsRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVpcEndpointServiceConfigurations, request); } /** * An Async wrapper for DeleteVpcEndpointServiceConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVpcEndpointServiceConfigurationsAsync(const DeleteVpcEndpointServiceConfigurationsRequestT& request, const DeleteVpcEndpointServiceConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVpcEndpointServiceConfigurations, request, handler, context); } /** *

Deletes the specified VPC endpoints.

When you delete a gateway * endpoint, we delete the endpoint routes in the route tables for the * endpoint.

When you delete a Gateway Load Balancer endpoint, we delete its * endpoint network interfaces. You can only delete Gateway Load Balancer endpoints * when the routes that are associated with the endpoint are deleted.

When * you delete an interface endpoint, we delete its endpoint network * interfaces.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVpcEndpointsOutcome DeleteVpcEndpoints(const Model::DeleteVpcEndpointsRequest& request) const; /** * A Callable wrapper for DeleteVpcEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVpcEndpointsOutcomeCallable DeleteVpcEndpointsCallable(const DeleteVpcEndpointsRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVpcEndpoints, request); } /** * An Async wrapper for DeleteVpcEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVpcEndpointsAsync(const DeleteVpcEndpointsRequestT& request, const DeleteVpcEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVpcEndpoints, request, handler, context); } /** *

Deletes a VPC peering connection. Either the owner of the requester VPC or * the owner of the accepter VPC can delete the VPC peering connection if it's in * the active state. The owner of the requester VPC can delete a VPC * peering connection in the pending-acceptance state. You cannot * delete a VPC peering connection that's in the failed * state.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVpcPeeringConnectionOutcome DeleteVpcPeeringConnection(const Model::DeleteVpcPeeringConnectionRequest& request) const; /** * A Callable wrapper for DeleteVpcPeeringConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVpcPeeringConnectionOutcomeCallable DeleteVpcPeeringConnectionCallable(const DeleteVpcPeeringConnectionRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVpcPeeringConnection, request); } /** * An Async wrapper for DeleteVpcPeeringConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVpcPeeringConnectionAsync(const DeleteVpcPeeringConnectionRequestT& request, const DeleteVpcPeeringConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVpcPeeringConnection, request, handler, context); } /** *

Deletes the specified VPN connection.

If you're deleting the VPC and * its associated components, we recommend that you detach the virtual private * gateway from the VPC and delete the VPC before deleting the VPN connection. If * you believe that the tunnel credentials for your VPN connection have been * compromised, you can delete the VPN connection and create a new one that has new * keys, without needing to delete the VPC or virtual private gateway. If you * create a new VPN connection, you must reconfigure the customer gateway device * using the new configuration information returned with the new VPN connection * ID.

For certificate-based authentication, delete all Certificate Manager * (ACM) private certificates used for the Amazon Web Services-side tunnel * endpoints for the VPN connection before deleting the VPN * connection.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVpnConnectionOutcome DeleteVpnConnection(const Model::DeleteVpnConnectionRequest& request) const; /** * A Callable wrapper for DeleteVpnConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVpnConnectionOutcomeCallable DeleteVpnConnectionCallable(const DeleteVpnConnectionRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVpnConnection, request); } /** * An Async wrapper for DeleteVpnConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVpnConnectionAsync(const DeleteVpnConnectionRequestT& request, const DeleteVpnConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVpnConnection, request, handler, context); } /** *

Deletes the specified static route associated with a VPN connection between * an existing virtual private gateway and a VPN customer gateway. The static route * allows traffic to be routed from the virtual private gateway to the VPN customer * gateway.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVpnConnectionRouteOutcome DeleteVpnConnectionRoute(const Model::DeleteVpnConnectionRouteRequest& request) const; /** * A Callable wrapper for DeleteVpnConnectionRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVpnConnectionRouteOutcomeCallable DeleteVpnConnectionRouteCallable(const DeleteVpnConnectionRouteRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVpnConnectionRoute, request); } /** * An Async wrapper for DeleteVpnConnectionRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVpnConnectionRouteAsync(const DeleteVpnConnectionRouteRequestT& request, const DeleteVpnConnectionRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVpnConnectionRoute, request, handler, context); } /** *

Deletes the specified virtual private gateway. You must first detach the * virtual private gateway from the VPC. Note that you don't need to delete the * virtual private gateway if you plan to delete and recreate the VPN connection * between your VPC and your network.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVpnGatewayOutcome DeleteVpnGateway(const Model::DeleteVpnGatewayRequest& request) const; /** * A Callable wrapper for DeleteVpnGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVpnGatewayOutcomeCallable DeleteVpnGatewayCallable(const DeleteVpnGatewayRequestT& request) const { return SubmitCallable(&EC2Client::DeleteVpnGateway, request); } /** * An Async wrapper for DeleteVpnGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVpnGatewayAsync(const DeleteVpnGatewayRequestT& request, const DeleteVpnGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeleteVpnGateway, request, handler, context); } /** *

Releases the specified address range that you provisioned for use with your * Amazon Web Services resources through bring your own IP addresses (BYOIP) and * deletes the corresponding address pool.

Before you can release an address * range, you must stop advertising it using WithdrawByoipCidr and you must * not have any IP addresses allocated from its address range.

See * Also:

AWS * API Reference

*/ virtual Model::DeprovisionByoipCidrOutcome DeprovisionByoipCidr(const Model::DeprovisionByoipCidrRequest& request) const; /** * A Callable wrapper for DeprovisionByoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeprovisionByoipCidrOutcomeCallable DeprovisionByoipCidrCallable(const DeprovisionByoipCidrRequestT& request) const { return SubmitCallable(&EC2Client::DeprovisionByoipCidr, request); } /** * An Async wrapper for DeprovisionByoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeprovisionByoipCidrAsync(const DeprovisionByoipCidrRequestT& request, const DeprovisionByoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeprovisionByoipCidr, request, handler, context); } /** *

Deprovision a CIDR provisioned from an IPAM pool. If you deprovision a CIDR * from a pool that has a source pool, the CIDR is recycled back into the source * pool. For more information, see Deprovision * pool CIDRs in the Amazon VPC IPAM User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DeprovisionIpamPoolCidrOutcome DeprovisionIpamPoolCidr(const Model::DeprovisionIpamPoolCidrRequest& request) const; /** * A Callable wrapper for DeprovisionIpamPoolCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeprovisionIpamPoolCidrOutcomeCallable DeprovisionIpamPoolCidrCallable(const DeprovisionIpamPoolCidrRequestT& request) const { return SubmitCallable(&EC2Client::DeprovisionIpamPoolCidr, request); } /** * An Async wrapper for DeprovisionIpamPoolCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeprovisionIpamPoolCidrAsync(const DeprovisionIpamPoolCidrRequestT& request, const DeprovisionIpamPoolCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeprovisionIpamPoolCidr, request, handler, context); } /** *

Deprovision a CIDR from a public IPv4 pool.

See Also:

AWS * API Reference

*/ virtual Model::DeprovisionPublicIpv4PoolCidrOutcome DeprovisionPublicIpv4PoolCidr(const Model::DeprovisionPublicIpv4PoolCidrRequest& request) const; /** * A Callable wrapper for DeprovisionPublicIpv4PoolCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeprovisionPublicIpv4PoolCidrOutcomeCallable DeprovisionPublicIpv4PoolCidrCallable(const DeprovisionPublicIpv4PoolCidrRequestT& request) const { return SubmitCallable(&EC2Client::DeprovisionPublicIpv4PoolCidr, request); } /** * An Async wrapper for DeprovisionPublicIpv4PoolCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeprovisionPublicIpv4PoolCidrAsync(const DeprovisionPublicIpv4PoolCidrRequestT& request, const DeprovisionPublicIpv4PoolCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeprovisionPublicIpv4PoolCidr, request, handler, context); } /** *

Deregisters the specified AMI. After you deregister an AMI, it can't be used * to launch new instances.

If you deregister an AMI that matches a Recycle * Bin retention rule, the AMI is retained in the Recycle Bin for the specified * retention period. For more information, see Recycle * Bin in the Amazon EC2 User Guide.

When you deregister an AMI, * it doesn't affect any instances that you've already launched from the AMI. * You'll continue to incur usage costs for those instances until you terminate * them.

When you deregister an Amazon EBS-backed AMI, it doesn't affect the * snapshot that was created for the root volume of the instance during the AMI * creation process. When you deregister an instance store-backed AMI, it doesn't * affect the files that you uploaded to Amazon S3 when you created the * AMI.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterImageOutcome DeregisterImage(const Model::DeregisterImageRequest& request) const; /** * A Callable wrapper for DeregisterImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterImageOutcomeCallable DeregisterImageCallable(const DeregisterImageRequestT& request) const { return SubmitCallable(&EC2Client::DeregisterImage, request); } /** * An Async wrapper for DeregisterImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterImageAsync(const DeregisterImageRequestT& request, const DeregisterImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeregisterImage, request, handler, context); } /** *

Deregisters tag keys to prevent tags that have the specified tag keys from * being included in scheduled event notifications for resources in the * Region.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterInstanceEventNotificationAttributesOutcome DeregisterInstanceEventNotificationAttributes(const Model::DeregisterInstanceEventNotificationAttributesRequest& request) const; /** * A Callable wrapper for DeregisterInstanceEventNotificationAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterInstanceEventNotificationAttributesOutcomeCallable DeregisterInstanceEventNotificationAttributesCallable(const DeregisterInstanceEventNotificationAttributesRequestT& request) const { return SubmitCallable(&EC2Client::DeregisterInstanceEventNotificationAttributes, request); } /** * An Async wrapper for DeregisterInstanceEventNotificationAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterInstanceEventNotificationAttributesAsync(const DeregisterInstanceEventNotificationAttributesRequestT& request, const DeregisterInstanceEventNotificationAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeregisterInstanceEventNotificationAttributes, request, handler, context); } /** *

Deregisters the specified members (network interfaces) from the transit * gateway multicast group.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterTransitGatewayMulticastGroupMembersOutcome DeregisterTransitGatewayMulticastGroupMembers(const Model::DeregisterTransitGatewayMulticastGroupMembersRequest& request) const; /** * A Callable wrapper for DeregisterTransitGatewayMulticastGroupMembers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterTransitGatewayMulticastGroupMembersOutcomeCallable DeregisterTransitGatewayMulticastGroupMembersCallable(const DeregisterTransitGatewayMulticastGroupMembersRequestT& request) const { return SubmitCallable(&EC2Client::DeregisterTransitGatewayMulticastGroupMembers, request); } /** * An Async wrapper for DeregisterTransitGatewayMulticastGroupMembers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterTransitGatewayMulticastGroupMembersAsync(const DeregisterTransitGatewayMulticastGroupMembersRequestT& request, const DeregisterTransitGatewayMulticastGroupMembersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeregisterTransitGatewayMulticastGroupMembers, request, handler, context); } /** *

Deregisters the specified sources (network interfaces) from the transit * gateway multicast group.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterTransitGatewayMulticastGroupSourcesOutcome DeregisterTransitGatewayMulticastGroupSources(const Model::DeregisterTransitGatewayMulticastGroupSourcesRequest& request) const; /** * A Callable wrapper for DeregisterTransitGatewayMulticastGroupSources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterTransitGatewayMulticastGroupSourcesOutcomeCallable DeregisterTransitGatewayMulticastGroupSourcesCallable(const DeregisterTransitGatewayMulticastGroupSourcesRequestT& request) const { return SubmitCallable(&EC2Client::DeregisterTransitGatewayMulticastGroupSources, request); } /** * An Async wrapper for DeregisterTransitGatewayMulticastGroupSources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterTransitGatewayMulticastGroupSourcesAsync(const DeregisterTransitGatewayMulticastGroupSourcesRequestT& request, const DeregisterTransitGatewayMulticastGroupSourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DeregisterTransitGatewayMulticastGroupSources, request, handler, context); } /** *

Describes attributes of your Amazon Web Services account. The following are * the supported account attributes:

  • default-vpc: * The ID of the default VPC for your account, or none.

  • *

    max-instances: This attribute is no longer supported. The * returned value does not reflect your actual vCPU limit for running On-Demand * Instances. For more information, see On-Demand * Instance Limits in the Amazon Elastic Compute Cloud User Guide.

    *

  • max-elastic-ips: The maximum number of Elastic IP * addresses that you can allocate.

  • * supported-platforms: This attribute is deprecated.

  • *

    vpc-max-elastic-ips: The maximum number of Elastic IP addresses * that you can allocate.

  • * vpc-max-security-groups-per-interface: The maximum number of * security groups that you can assign to a network interface.

    • *

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountAttributesOutcome DescribeAccountAttributes(const Model::DescribeAccountAttributesRequest& request) const; /** * A Callable wrapper for DescribeAccountAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountAttributesOutcomeCallable DescribeAccountAttributesCallable(const DescribeAccountAttributesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeAccountAttributes, request); } /** * An Async wrapper for DescribeAccountAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountAttributesAsync(const DescribeAccountAttributesRequestT& request, const DescribeAccountAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeAccountAttributes, request, handler, context); } /** *

Describes an Elastic IP address transfer. For more information, see Transfer * Elastic IP addresses in the Amazon Virtual Private Cloud User * Guide.

When you transfer an Elastic IP address, there is a two-step * handshake between the source and transfer Amazon Web Services accounts. When the * source account starts the transfer, the transfer account has seven days to * accept the Elastic IP address transfer. During those seven days, the source * account can view the pending transfer by using this action. After seven days, * the transfer expires and ownership of the Elastic IP address returns to the * source account. Accepted transfers are visible to the source account for three * days after the transfers have been accepted.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAddressTransfersOutcome DescribeAddressTransfers(const Model::DescribeAddressTransfersRequest& request) const; /** * A Callable wrapper for DescribeAddressTransfers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAddressTransfersOutcomeCallable DescribeAddressTransfersCallable(const DescribeAddressTransfersRequestT& request) const { return SubmitCallable(&EC2Client::DescribeAddressTransfers, request); } /** * An Async wrapper for DescribeAddressTransfers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAddressTransfersAsync(const DescribeAddressTransfersRequestT& request, const DescribeAddressTransfersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeAddressTransfers, request, handler, context); } /** *

Describes the specified Elastic IP addresses or all of your Elastic IP * addresses.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAddressesOutcome DescribeAddresses(const Model::DescribeAddressesRequest& request) const; /** * A Callable wrapper for DescribeAddresses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAddressesOutcomeCallable DescribeAddressesCallable(const DescribeAddressesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeAddresses, request); } /** * An Async wrapper for DescribeAddresses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAddressesAsync(const DescribeAddressesRequestT& request, const DescribeAddressesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeAddresses, request, handler, context); } /** *

Describes the attributes of the specified Elastic IP addresses. For * requirements, see Using * reverse DNS for email applications.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAddressesAttributeOutcome DescribeAddressesAttribute(const Model::DescribeAddressesAttributeRequest& request) const; /** * A Callable wrapper for DescribeAddressesAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAddressesAttributeOutcomeCallable DescribeAddressesAttributeCallable(const DescribeAddressesAttributeRequestT& request) const { return SubmitCallable(&EC2Client::DescribeAddressesAttribute, request); } /** * An Async wrapper for DescribeAddressesAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAddressesAttributeAsync(const DescribeAddressesAttributeRequestT& request, const DescribeAddressesAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeAddressesAttribute, request, handler, context); } /** *

Describes the longer ID format settings for all resource types in a specific * Region. This request is useful for performing a quick audit to determine whether * a specific Region is fully opted in for longer IDs (17-character IDs).

*

This request only returns information about resource types that support * longer IDs.

The following resource types support longer IDs: * bundle | conversion-task | * customer-gateway | dhcp-options | * elastic-ip-allocation | elastic-ip-association | * export-task | flow-log | image | * import-task | instance | internet-gateway * | network-acl | network-acl-association | * network-interface | network-interface-attachment | * prefix-list | reservation | route-table | * route-table-association | security-group | * snapshot | subnet | * subnet-cidr-block-association | volume | * vpc | vpc-cidr-block-association | * vpc-endpoint | vpc-peering-connection | * vpn-connection | vpn-gateway.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeAggregateIdFormatOutcome DescribeAggregateIdFormat(const Model::DescribeAggregateIdFormatRequest& request) const; /** * A Callable wrapper for DescribeAggregateIdFormat that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAggregateIdFormatOutcomeCallable DescribeAggregateIdFormatCallable(const DescribeAggregateIdFormatRequestT& request) const { return SubmitCallable(&EC2Client::DescribeAggregateIdFormat, request); } /** * An Async wrapper for DescribeAggregateIdFormat that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAggregateIdFormatAsync(const DescribeAggregateIdFormatRequestT& request, const DescribeAggregateIdFormatResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeAggregateIdFormat, request, handler, context); } /** *

Describes the Availability Zones, Local Zones, and Wavelength Zones that are * available to you. If there is an event impacting a zone, you can use this * request to view the state and any provided messages for that zone.

For * more information about Availability Zones, Local Zones, and Wavelength Zones, * see Regions * and zones in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAvailabilityZonesOutcome DescribeAvailabilityZones(const Model::DescribeAvailabilityZonesRequest& request) const; /** * A Callable wrapper for DescribeAvailabilityZones that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAvailabilityZonesOutcomeCallable DescribeAvailabilityZonesCallable(const DescribeAvailabilityZonesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeAvailabilityZones, request); } /** * An Async wrapper for DescribeAvailabilityZones that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAvailabilityZonesAsync(const DescribeAvailabilityZonesRequestT& request, const DescribeAvailabilityZonesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeAvailabilityZones, request, handler, context); } /** *

Describes the current Infrastructure Performance metric * subscriptions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAwsNetworkPerformanceMetricSubscriptionsOutcome DescribeAwsNetworkPerformanceMetricSubscriptions(const Model::DescribeAwsNetworkPerformanceMetricSubscriptionsRequest& request) const; /** * A Callable wrapper for DescribeAwsNetworkPerformanceMetricSubscriptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAwsNetworkPerformanceMetricSubscriptionsOutcomeCallable DescribeAwsNetworkPerformanceMetricSubscriptionsCallable(const DescribeAwsNetworkPerformanceMetricSubscriptionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeAwsNetworkPerformanceMetricSubscriptions, request); } /** * An Async wrapper for DescribeAwsNetworkPerformanceMetricSubscriptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAwsNetworkPerformanceMetricSubscriptionsAsync(const DescribeAwsNetworkPerformanceMetricSubscriptionsRequestT& request, const DescribeAwsNetworkPerformanceMetricSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeAwsNetworkPerformanceMetricSubscriptions, request, handler, context); } /** *

Describes the specified bundle tasks or all of your bundle tasks.

*

Completed bundle tasks are listed for only a limited time. If your bundle * task is no longer in the list, you can still register an AMI from it. Just use * RegisterImage with the Amazon S3 bucket name and image manifest * name you provided to the bundle task.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBundleTasksOutcome DescribeBundleTasks(const Model::DescribeBundleTasksRequest& request) const; /** * A Callable wrapper for DescribeBundleTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBundleTasksOutcomeCallable DescribeBundleTasksCallable(const DescribeBundleTasksRequestT& request) const { return SubmitCallable(&EC2Client::DescribeBundleTasks, request); } /** * An Async wrapper for DescribeBundleTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBundleTasksAsync(const DescribeBundleTasksRequestT& request, const DescribeBundleTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeBundleTasks, request, handler, context); } /** *

Describes the IP address ranges that were specified in calls to * ProvisionByoipCidr.

To describe the address pools that were * created when you provisioned the address ranges, use * DescribePublicIpv4Pools or DescribeIpv6Pools.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeByoipCidrsOutcome DescribeByoipCidrs(const Model::DescribeByoipCidrsRequest& request) const; /** * A Callable wrapper for DescribeByoipCidrs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeByoipCidrsOutcomeCallable DescribeByoipCidrsCallable(const DescribeByoipCidrsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeByoipCidrs, request); } /** * An Async wrapper for DescribeByoipCidrs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeByoipCidrsAsync(const DescribeByoipCidrsRequestT& request, const DescribeByoipCidrsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeByoipCidrs, request, handler, context); } /** *

Describes one or more Capacity Reservation Fleets.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeCapacityReservationFleetsOutcome DescribeCapacityReservationFleets(const Model::DescribeCapacityReservationFleetsRequest& request) const; /** * A Callable wrapper for DescribeCapacityReservationFleets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCapacityReservationFleetsOutcomeCallable DescribeCapacityReservationFleetsCallable(const DescribeCapacityReservationFleetsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeCapacityReservationFleets, request); } /** * An Async wrapper for DescribeCapacityReservationFleets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCapacityReservationFleetsAsync(const DescribeCapacityReservationFleetsRequestT& request, const DescribeCapacityReservationFleetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeCapacityReservationFleets, request, handler, context); } /** *

Describes one or more of your Capacity Reservations. The results describe * only the Capacity Reservations in the Amazon Web Services Region that you're * currently using.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCapacityReservationsOutcome DescribeCapacityReservations(const Model::DescribeCapacityReservationsRequest& request) const; /** * A Callable wrapper for DescribeCapacityReservations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCapacityReservationsOutcomeCallable DescribeCapacityReservationsCallable(const DescribeCapacityReservationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeCapacityReservations, request); } /** * An Async wrapper for DescribeCapacityReservations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCapacityReservationsAsync(const DescribeCapacityReservationsRequestT& request, const DescribeCapacityReservationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeCapacityReservations, request, handler, context); } /** *

Describes one or more of your carrier gateways.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCarrierGatewaysOutcome DescribeCarrierGateways(const Model::DescribeCarrierGatewaysRequest& request) const; /** * A Callable wrapper for DescribeCarrierGateways that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCarrierGatewaysOutcomeCallable DescribeCarrierGatewaysCallable(const DescribeCarrierGatewaysRequestT& request) const { return SubmitCallable(&EC2Client::DescribeCarrierGateways, request); } /** * An Async wrapper for DescribeCarrierGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCarrierGatewaysAsync(const DescribeCarrierGatewaysRequestT& request, const DescribeCarrierGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeCarrierGateways, request, handler, context); } /** *

This action is deprecated.

Describes one or more of * your linked EC2-Classic instances. This request only returns information about * EC2-Classic instances linked to a VPC through ClassicLink. You cannot use this * request to return information about other instances.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeClassicLinkInstancesOutcome DescribeClassicLinkInstances(const Model::DescribeClassicLinkInstancesRequest& request) const; /** * A Callable wrapper for DescribeClassicLinkInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClassicLinkInstancesOutcomeCallable DescribeClassicLinkInstancesCallable(const DescribeClassicLinkInstancesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeClassicLinkInstances, request); } /** * An Async wrapper for DescribeClassicLinkInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClassicLinkInstancesAsync(const DescribeClassicLinkInstancesRequestT& request, const DescribeClassicLinkInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeClassicLinkInstances, request, handler, context); } /** *

Describes the authorization rules for a specified Client VPN * endpoint.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClientVpnAuthorizationRulesOutcome DescribeClientVpnAuthorizationRules(const Model::DescribeClientVpnAuthorizationRulesRequest& request) const; /** * A Callable wrapper for DescribeClientVpnAuthorizationRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClientVpnAuthorizationRulesOutcomeCallable DescribeClientVpnAuthorizationRulesCallable(const DescribeClientVpnAuthorizationRulesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeClientVpnAuthorizationRules, request); } /** * An Async wrapper for DescribeClientVpnAuthorizationRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClientVpnAuthorizationRulesAsync(const DescribeClientVpnAuthorizationRulesRequestT& request, const DescribeClientVpnAuthorizationRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeClientVpnAuthorizationRules, request, handler, context); } /** *

Describes active client connections and connections that have been terminated * within the last 60 minutes for the specified Client VPN endpoint.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeClientVpnConnectionsOutcome DescribeClientVpnConnections(const Model::DescribeClientVpnConnectionsRequest& request) const; /** * A Callable wrapper for DescribeClientVpnConnections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClientVpnConnectionsOutcomeCallable DescribeClientVpnConnectionsCallable(const DescribeClientVpnConnectionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeClientVpnConnections, request); } /** * An Async wrapper for DescribeClientVpnConnections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClientVpnConnectionsAsync(const DescribeClientVpnConnectionsRequestT& request, const DescribeClientVpnConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeClientVpnConnections, request, handler, context); } /** *

Describes one or more Client VPN endpoints in the account.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeClientVpnEndpointsOutcome DescribeClientVpnEndpoints(const Model::DescribeClientVpnEndpointsRequest& request) const; /** * A Callable wrapper for DescribeClientVpnEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClientVpnEndpointsOutcomeCallable DescribeClientVpnEndpointsCallable(const DescribeClientVpnEndpointsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeClientVpnEndpoints, request); } /** * An Async wrapper for DescribeClientVpnEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClientVpnEndpointsAsync(const DescribeClientVpnEndpointsRequestT& request, const DescribeClientVpnEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeClientVpnEndpoints, request, handler, context); } /** *

Describes the routes for the specified Client VPN endpoint.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeClientVpnRoutesOutcome DescribeClientVpnRoutes(const Model::DescribeClientVpnRoutesRequest& request) const; /** * A Callable wrapper for DescribeClientVpnRoutes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClientVpnRoutesOutcomeCallable DescribeClientVpnRoutesCallable(const DescribeClientVpnRoutesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeClientVpnRoutes, request); } /** * An Async wrapper for DescribeClientVpnRoutes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClientVpnRoutesAsync(const DescribeClientVpnRoutesRequestT& request, const DescribeClientVpnRoutesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeClientVpnRoutes, request, handler, context); } /** *

Describes the target networks associated with the specified Client VPN * endpoint.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClientVpnTargetNetworksOutcome DescribeClientVpnTargetNetworks(const Model::DescribeClientVpnTargetNetworksRequest& request) const; /** * A Callable wrapper for DescribeClientVpnTargetNetworks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClientVpnTargetNetworksOutcomeCallable DescribeClientVpnTargetNetworksCallable(const DescribeClientVpnTargetNetworksRequestT& request) const { return SubmitCallable(&EC2Client::DescribeClientVpnTargetNetworks, request); } /** * An Async wrapper for DescribeClientVpnTargetNetworks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClientVpnTargetNetworksAsync(const DescribeClientVpnTargetNetworksRequestT& request, const DescribeClientVpnTargetNetworksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeClientVpnTargetNetworks, request, handler, context); } /** *

Describes the specified customer-owned address pools or all of your * customer-owned address pools.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCoipPoolsOutcome DescribeCoipPools(const Model::DescribeCoipPoolsRequest& request) const; /** * A Callable wrapper for DescribeCoipPools that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCoipPoolsOutcomeCallable DescribeCoipPoolsCallable(const DescribeCoipPoolsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeCoipPools, request); } /** * An Async wrapper for DescribeCoipPools that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCoipPoolsAsync(const DescribeCoipPoolsRequestT& request, const DescribeCoipPoolsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeCoipPools, request, handler, context); } /** *

Describes the specified conversion tasks or all your conversion tasks. For * more information, see the VM Import/Export * User Guide.

For information about the import manifest referenced by * this API action, see VM * Import Manifest.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConversionTasksOutcome DescribeConversionTasks(const Model::DescribeConversionTasksRequest& request) const; /** * A Callable wrapper for DescribeConversionTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConversionTasksOutcomeCallable DescribeConversionTasksCallable(const DescribeConversionTasksRequestT& request) const { return SubmitCallable(&EC2Client::DescribeConversionTasks, request); } /** * An Async wrapper for DescribeConversionTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConversionTasksAsync(const DescribeConversionTasksRequestT& request, const DescribeConversionTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeConversionTasks, request, handler, context); } /** *

Describes one or more of your VPN customer gateways.

For more * information, see Amazon Web * Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCustomerGatewaysOutcome DescribeCustomerGateways(const Model::DescribeCustomerGatewaysRequest& request) const; /** * A Callable wrapper for DescribeCustomerGateways that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCustomerGatewaysOutcomeCallable DescribeCustomerGatewaysCallable(const DescribeCustomerGatewaysRequestT& request) const { return SubmitCallable(&EC2Client::DescribeCustomerGateways, request); } /** * An Async wrapper for DescribeCustomerGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCustomerGatewaysAsync(const DescribeCustomerGatewaysRequestT& request, const DescribeCustomerGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeCustomerGateways, request, handler, context); } /** *

Describes one or more of your DHCP options sets.

For more information, * see DHCP * options sets in the Amazon VPC User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeDhcpOptionsOutcome DescribeDhcpOptions(const Model::DescribeDhcpOptionsRequest& request) const; /** * A Callable wrapper for DescribeDhcpOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDhcpOptionsOutcomeCallable DescribeDhcpOptionsCallable(const DescribeDhcpOptionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeDhcpOptions, request); } /** * An Async wrapper for DescribeDhcpOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDhcpOptionsAsync(const DescribeDhcpOptionsRequestT& request, const DescribeDhcpOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeDhcpOptions, request, handler, context); } /** *

Describes one or more of your egress-only internet gateways.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeEgressOnlyInternetGatewaysOutcome DescribeEgressOnlyInternetGateways(const Model::DescribeEgressOnlyInternetGatewaysRequest& request) const; /** * A Callable wrapper for DescribeEgressOnlyInternetGateways that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEgressOnlyInternetGatewaysOutcomeCallable DescribeEgressOnlyInternetGatewaysCallable(const DescribeEgressOnlyInternetGatewaysRequestT& request) const { return SubmitCallable(&EC2Client::DescribeEgressOnlyInternetGateways, request); } /** * An Async wrapper for DescribeEgressOnlyInternetGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEgressOnlyInternetGatewaysAsync(const DescribeEgressOnlyInternetGatewaysRequestT& request, const DescribeEgressOnlyInternetGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeEgressOnlyInternetGateways, request, handler, context); } /** *

Describes the Elastic Graphics accelerator associated with your instances. * For more information about Elastic Graphics, see Amazon * Elastic Graphics.

See Also:

AWS * API Reference

*/ virtual Model::DescribeElasticGpusOutcome DescribeElasticGpus(const Model::DescribeElasticGpusRequest& request) const; /** * A Callable wrapper for DescribeElasticGpus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeElasticGpusOutcomeCallable DescribeElasticGpusCallable(const DescribeElasticGpusRequestT& request) const { return SubmitCallable(&EC2Client::DescribeElasticGpus, request); } /** * An Async wrapper for DescribeElasticGpus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeElasticGpusAsync(const DescribeElasticGpusRequestT& request, const DescribeElasticGpusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeElasticGpus, request, handler, context); } /** *

Describes the specified export image tasks or all of your export image * tasks.

See Also:

AWS * API Reference

*/ virtual Model::DescribeExportImageTasksOutcome DescribeExportImageTasks(const Model::DescribeExportImageTasksRequest& request) const; /** * A Callable wrapper for DescribeExportImageTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeExportImageTasksOutcomeCallable DescribeExportImageTasksCallable(const DescribeExportImageTasksRequestT& request) const { return SubmitCallable(&EC2Client::DescribeExportImageTasks, request); } /** * An Async wrapper for DescribeExportImageTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeExportImageTasksAsync(const DescribeExportImageTasksRequestT& request, const DescribeExportImageTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeExportImageTasks, request, handler, context); } /** *

Describes the specified export instance tasks or all of your export instance * tasks.

See Also:

AWS * API Reference

*/ virtual Model::DescribeExportTasksOutcome DescribeExportTasks(const Model::DescribeExportTasksRequest& request) const; /** * A Callable wrapper for DescribeExportTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeExportTasksOutcomeCallable DescribeExportTasksCallable(const DescribeExportTasksRequestT& request) const { return SubmitCallable(&EC2Client::DescribeExportTasks, request); } /** * An Async wrapper for DescribeExportTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeExportTasksAsync(const DescribeExportTasksRequestT& request, const DescribeExportTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeExportTasks, request, handler, context); } /** *

Describe details for Windows AMIs that are configured for faster * launching.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFastLaunchImagesOutcome DescribeFastLaunchImages(const Model::DescribeFastLaunchImagesRequest& request) const; /** * A Callable wrapper for DescribeFastLaunchImages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFastLaunchImagesOutcomeCallable DescribeFastLaunchImagesCallable(const DescribeFastLaunchImagesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeFastLaunchImages, request); } /** * An Async wrapper for DescribeFastLaunchImages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFastLaunchImagesAsync(const DescribeFastLaunchImagesRequestT& request, const DescribeFastLaunchImagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeFastLaunchImages, request, handler, context); } /** *

Describes the state of fast snapshot restores for your * snapshots.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFastSnapshotRestoresOutcome DescribeFastSnapshotRestores(const Model::DescribeFastSnapshotRestoresRequest& request) const; /** * A Callable wrapper for DescribeFastSnapshotRestores that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFastSnapshotRestoresOutcomeCallable DescribeFastSnapshotRestoresCallable(const DescribeFastSnapshotRestoresRequestT& request) const { return SubmitCallable(&EC2Client::DescribeFastSnapshotRestores, request); } /** * An Async wrapper for DescribeFastSnapshotRestores that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFastSnapshotRestoresAsync(const DescribeFastSnapshotRestoresRequestT& request, const DescribeFastSnapshotRestoresResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeFastSnapshotRestores, request, handler, context); } /** *

Describes the events for the specified EC2 Fleet during the specified * time.

EC2 Fleet events are delayed by up to 30 seconds before they can be * described. This ensures that you can query by the last evaluated time and not * miss a recorded event. EC2 Fleet events are available for 48 hours.

For * more information, see Monitor * fleet events using Amazon EventBridge in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFleetHistoryOutcome DescribeFleetHistory(const Model::DescribeFleetHistoryRequest& request) const; /** * A Callable wrapper for DescribeFleetHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFleetHistoryOutcomeCallable DescribeFleetHistoryCallable(const DescribeFleetHistoryRequestT& request) const { return SubmitCallable(&EC2Client::DescribeFleetHistory, request); } /** * An Async wrapper for DescribeFleetHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFleetHistoryAsync(const DescribeFleetHistoryRequestT& request, const DescribeFleetHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeFleetHistory, request, handler, context); } /** *

Describes the running instances for the specified EC2 Fleet.

For more * information, see Monitor * your EC2 Fleet in the Amazon EC2 User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeFleetInstancesOutcome DescribeFleetInstances(const Model::DescribeFleetInstancesRequest& request) const; /** * A Callable wrapper for DescribeFleetInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFleetInstancesOutcomeCallable DescribeFleetInstancesCallable(const DescribeFleetInstancesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeFleetInstances, request); } /** * An Async wrapper for DescribeFleetInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFleetInstancesAsync(const DescribeFleetInstancesRequestT& request, const DescribeFleetInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeFleetInstances, request, handler, context); } /** *

Describes the specified EC2 Fleets or all of your EC2 Fleets.

For more * information, see Monitor * your EC2 Fleet in the Amazon EC2 User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeFleetsOutcome DescribeFleets(const Model::DescribeFleetsRequest& request) const; /** * A Callable wrapper for DescribeFleets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFleetsOutcomeCallable DescribeFleetsCallable(const DescribeFleetsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeFleets, request); } /** * An Async wrapper for DescribeFleets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFleetsAsync(const DescribeFleetsRequestT& request, const DescribeFleetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeFleets, request, handler, context); } /** *

Describes one or more flow logs.

To view the published flow log * records, you must view the log destination. For example, the CloudWatch Logs log * group, the Amazon S3 bucket, or the Kinesis Data Firehose delivery * stream.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFlowLogsOutcome DescribeFlowLogs(const Model::DescribeFlowLogsRequest& request) const; /** * A Callable wrapper for DescribeFlowLogs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFlowLogsOutcomeCallable DescribeFlowLogsCallable(const DescribeFlowLogsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeFlowLogs, request); } /** * An Async wrapper for DescribeFlowLogs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFlowLogsAsync(const DescribeFlowLogsRequestT& request, const DescribeFlowLogsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeFlowLogs, request, handler, context); } /** *

Describes the specified attribute of the specified Amazon FPGA Image * (AFI).

See Also:

AWS * API Reference

*/ virtual Model::DescribeFpgaImageAttributeOutcome DescribeFpgaImageAttribute(const Model::DescribeFpgaImageAttributeRequest& request) const; /** * A Callable wrapper for DescribeFpgaImageAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFpgaImageAttributeOutcomeCallable DescribeFpgaImageAttributeCallable(const DescribeFpgaImageAttributeRequestT& request) const { return SubmitCallable(&EC2Client::DescribeFpgaImageAttribute, request); } /** * An Async wrapper for DescribeFpgaImageAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFpgaImageAttributeAsync(const DescribeFpgaImageAttributeRequestT& request, const DescribeFpgaImageAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeFpgaImageAttribute, request, handler, context); } /** *

Describes the Amazon FPGA Images (AFIs) available to you. These include * public AFIs, private AFIs that you own, and AFIs owned by other Amazon Web * Services accounts for which you have load permissions.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeFpgaImagesOutcome DescribeFpgaImages(const Model::DescribeFpgaImagesRequest& request) const; /** * A Callable wrapper for DescribeFpgaImages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFpgaImagesOutcomeCallable DescribeFpgaImagesCallable(const DescribeFpgaImagesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeFpgaImages, request); } /** * An Async wrapper for DescribeFpgaImages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFpgaImagesAsync(const DescribeFpgaImagesRequestT& request, const DescribeFpgaImagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeFpgaImages, request, handler, context); } /** *

Describes the Dedicated Host reservations that are available to purchase.

*

The results describe all of the Dedicated Host reservation offerings, * including offerings that might not match the instance family and Region of your * Dedicated Hosts. When purchasing an offering, ensure that the instance family * and Region of the offering matches that of the Dedicated Hosts with which it is * to be associated. For more information about supported instance types, see Dedicated * Hosts in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHostReservationOfferingsOutcome DescribeHostReservationOfferings(const Model::DescribeHostReservationOfferingsRequest& request) const; /** * A Callable wrapper for DescribeHostReservationOfferings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHostReservationOfferingsOutcomeCallable DescribeHostReservationOfferingsCallable(const DescribeHostReservationOfferingsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeHostReservationOfferings, request); } /** * An Async wrapper for DescribeHostReservationOfferings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHostReservationOfferingsAsync(const DescribeHostReservationOfferingsRequestT& request, const DescribeHostReservationOfferingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeHostReservationOfferings, request, handler, context); } /** *

Describes reservations that are associated with Dedicated Hosts in your * account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHostReservationsOutcome DescribeHostReservations(const Model::DescribeHostReservationsRequest& request) const; /** * A Callable wrapper for DescribeHostReservations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHostReservationsOutcomeCallable DescribeHostReservationsCallable(const DescribeHostReservationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeHostReservations, request); } /** * An Async wrapper for DescribeHostReservations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHostReservationsAsync(const DescribeHostReservationsRequestT& request, const DescribeHostReservationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeHostReservations, request, handler, context); } /** *

Describes the specified Dedicated Hosts or all your Dedicated Hosts.

*

The results describe only the Dedicated Hosts in the Region you're currently * using. All listed instances consume capacity on your Dedicated Host. Dedicated * Hosts that have recently been released are listed with the state * released.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHostsOutcome DescribeHosts(const Model::DescribeHostsRequest& request) const; /** * A Callable wrapper for DescribeHosts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHostsOutcomeCallable DescribeHostsCallable(const DescribeHostsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeHosts, request); } /** * An Async wrapper for DescribeHosts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHostsAsync(const DescribeHostsRequestT& request, const DescribeHostsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeHosts, request, handler, context); } /** *

Describes your IAM instance profile associations.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeIamInstanceProfileAssociationsOutcome DescribeIamInstanceProfileAssociations(const Model::DescribeIamInstanceProfileAssociationsRequest& request) const; /** * A Callable wrapper for DescribeIamInstanceProfileAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIamInstanceProfileAssociationsOutcomeCallable DescribeIamInstanceProfileAssociationsCallable(const DescribeIamInstanceProfileAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeIamInstanceProfileAssociations, request); } /** * An Async wrapper for DescribeIamInstanceProfileAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIamInstanceProfileAssociationsAsync(const DescribeIamInstanceProfileAssociationsRequestT& request, const DescribeIamInstanceProfileAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeIamInstanceProfileAssociations, request, handler, context); } /** *

Describes the ID format settings for your resources on a per-Region basis, * for example, to view which resource types are enabled for longer IDs. This * request only returns information about resource types whose ID formats can be * modified; it does not return information about other resource types.

The * following resource types support longer IDs: bundle | * conversion-task | customer-gateway | * dhcp-options | elastic-ip-allocation | * elastic-ip-association | export-task | * flow-log | image | import-task | * instance | internet-gateway | network-acl * | network-acl-association | network-interface | * network-interface-attachment | prefix-list | * reservation | route-table | * route-table-association | security-group | * snapshot | subnet | * subnet-cidr-block-association | volume | * vpc | vpc-cidr-block-association | * vpc-endpoint | vpc-peering-connection | * vpn-connection | vpn-gateway.

These settings * apply to the IAM user who makes the request; they do not apply to the entire * Amazon Web Services account. By default, an IAM user defaults to the same * settings as the root user, unless they explicitly override the settings by * running the ModifyIdFormat command. Resources created with longer IDs are * visible to all IAM users, regardless of these settings and provided that they * have permission to use the relevant Describe command for the * resource type.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIdFormatOutcome DescribeIdFormat(const Model::DescribeIdFormatRequest& request) const; /** * A Callable wrapper for DescribeIdFormat that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIdFormatOutcomeCallable DescribeIdFormatCallable(const DescribeIdFormatRequestT& request) const { return SubmitCallable(&EC2Client::DescribeIdFormat, request); } /** * An Async wrapper for DescribeIdFormat that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIdFormatAsync(const DescribeIdFormatRequestT& request, const DescribeIdFormatResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeIdFormat, request, handler, context); } /** *

Describes the ID format settings for resources for the specified IAM user, * IAM role, or root user. For example, you can view the resource types that are * enabled for longer IDs. This request only returns information about resource * types whose ID formats can be modified; it does not return information about * other resource types. For more information, see Resource * IDs in the Amazon Elastic Compute Cloud User Guide.

The * following resource types support longer IDs: bundle | * conversion-task | customer-gateway | * dhcp-options | elastic-ip-allocation | * elastic-ip-association | export-task | * flow-log | image | import-task | * instance | internet-gateway | network-acl * | network-acl-association | network-interface | * network-interface-attachment | prefix-list | * reservation | route-table | * route-table-association | security-group | * snapshot | subnet | * subnet-cidr-block-association | volume | * vpc | vpc-cidr-block-association | * vpc-endpoint | vpc-peering-connection | * vpn-connection | vpn-gateway.

These settings * apply to the principal specified in the request. They do not apply to the * principal that makes the request.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIdentityIdFormatOutcome DescribeIdentityIdFormat(const Model::DescribeIdentityIdFormatRequest& request) const; /** * A Callable wrapper for DescribeIdentityIdFormat that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIdentityIdFormatOutcomeCallable DescribeIdentityIdFormatCallable(const DescribeIdentityIdFormatRequestT& request) const { return SubmitCallable(&EC2Client::DescribeIdentityIdFormat, request); } /** * An Async wrapper for DescribeIdentityIdFormat that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIdentityIdFormatAsync(const DescribeIdentityIdFormatRequestT& request, const DescribeIdentityIdFormatResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeIdentityIdFormat, request, handler, context); } /** *

Describes the specified attribute of the specified AMI. You can specify only * one attribute at a time.

See Also:

AWS * API Reference

*/ virtual Model::DescribeImageAttributeOutcome DescribeImageAttribute(const Model::DescribeImageAttributeRequest& request) const; /** * A Callable wrapper for DescribeImageAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImageAttributeOutcomeCallable DescribeImageAttributeCallable(const DescribeImageAttributeRequestT& request) const { return SubmitCallable(&EC2Client::DescribeImageAttribute, request); } /** * An Async wrapper for DescribeImageAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImageAttributeAsync(const DescribeImageAttributeRequestT& request, const DescribeImageAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeImageAttribute, request, handler, context); } /** *

Describes the specified images (AMIs, AKIs, and ARIs) available to you or all * of the images available to you.

The images available to you include * public images, private images that you own, and private images owned by other * Amazon Web Services accounts for which you have explicit launch permissions.

*

Recently deregistered images appear in the returned results for a short * interval and then return empty results. After all instances that reference a * deregistered AMI are terminated, specifying the ID of the image will eventually * return an error indicating that the AMI ID cannot be found.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeImagesOutcome DescribeImages(const Model::DescribeImagesRequest& request) const; /** * A Callable wrapper for DescribeImages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImagesOutcomeCallable DescribeImagesCallable(const DescribeImagesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeImages, request); } /** * An Async wrapper for DescribeImages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImagesAsync(const DescribeImagesRequestT& request, const DescribeImagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeImages, request, handler, context); } /** *

Displays details about an import virtual machine or import snapshot tasks * that are already created.

See Also:

AWS * API Reference

*/ virtual Model::DescribeImportImageTasksOutcome DescribeImportImageTasks(const Model::DescribeImportImageTasksRequest& request) const; /** * A Callable wrapper for DescribeImportImageTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImportImageTasksOutcomeCallable DescribeImportImageTasksCallable(const DescribeImportImageTasksRequestT& request) const { return SubmitCallable(&EC2Client::DescribeImportImageTasks, request); } /** * An Async wrapper for DescribeImportImageTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImportImageTasksAsync(const DescribeImportImageTasksRequestT& request, const DescribeImportImageTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeImportImageTasks, request, handler, context); } /** *

Describes your import snapshot tasks.

See Also:

AWS * API Reference

*/ virtual Model::DescribeImportSnapshotTasksOutcome DescribeImportSnapshotTasks(const Model::DescribeImportSnapshotTasksRequest& request) const; /** * A Callable wrapper for DescribeImportSnapshotTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImportSnapshotTasksOutcomeCallable DescribeImportSnapshotTasksCallable(const DescribeImportSnapshotTasksRequestT& request) const { return SubmitCallable(&EC2Client::DescribeImportSnapshotTasks, request); } /** * An Async wrapper for DescribeImportSnapshotTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImportSnapshotTasksAsync(const DescribeImportSnapshotTasksRequestT& request, const DescribeImportSnapshotTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeImportSnapshotTasks, request, handler, context); } /** *

Describes the specified attribute of the specified instance. You can specify * only one attribute at a time. Valid attribute values are: * instanceType | kernel | ramdisk | * userData | disableApiTermination | * instanceInitiatedShutdownBehavior | rootDeviceName | * blockDeviceMapping | productCodes | * sourceDestCheck | groupSet | ebsOptimized * | sriovNetSupport

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceAttributeOutcome DescribeInstanceAttribute(const Model::DescribeInstanceAttributeRequest& request) const; /** * A Callable wrapper for DescribeInstanceAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceAttributeOutcomeCallable DescribeInstanceAttributeCallable(const DescribeInstanceAttributeRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInstanceAttribute, request); } /** * An Async wrapper for DescribeInstanceAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceAttributeAsync(const DescribeInstanceAttributeRequestT& request, const DescribeInstanceAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInstanceAttribute, request, handler, context); } /** *

Describes the specified EC2 Instance Connect Endpoints or all EC2 Instance * Connect Endpoints.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceConnectEndpointsOutcome DescribeInstanceConnectEndpoints(const Model::DescribeInstanceConnectEndpointsRequest& request) const; /** * A Callable wrapper for DescribeInstanceConnectEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceConnectEndpointsOutcomeCallable DescribeInstanceConnectEndpointsCallable(const DescribeInstanceConnectEndpointsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInstanceConnectEndpoints, request); } /** * An Async wrapper for DescribeInstanceConnectEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceConnectEndpointsAsync(const DescribeInstanceConnectEndpointsRequestT& request, const DescribeInstanceConnectEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInstanceConnectEndpoints, request, handler, context); } /** *

Describes the credit option for CPU usage of the specified burstable * performance instances. The credit options are standard and * unlimited.

If you do not specify an instance ID, Amazon EC2 * returns burstable performance instances with the unlimited credit * option, as well as instances that were previously configured as T2, T3, and T3a * with the unlimited credit option. For example, if you resize a T2 * instance, while it is configured as unlimited, to an M4 instance, * Amazon EC2 returns the M4 instance.

If you specify one or more instance * IDs, Amazon EC2 returns the credit option (standard or * unlimited) of those instances. If you specify an instance ID that * is not valid, such as an instance that is not a burstable performance instance, * an error is returned.

Recently terminated instances might appear in the * returned results. This interval is usually less than one hour.

If an * Availability Zone is experiencing a service disruption and you specify instance * IDs in the affected zone, or do not specify any instance IDs at all, the call * fails. If you specify only instance IDs in an unaffected zone, the call works * normally.

For more information, see Burstable * performance instances in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceCreditSpecificationsOutcome DescribeInstanceCreditSpecifications(const Model::DescribeInstanceCreditSpecificationsRequest& request) const; /** * A Callable wrapper for DescribeInstanceCreditSpecifications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceCreditSpecificationsOutcomeCallable DescribeInstanceCreditSpecificationsCallable(const DescribeInstanceCreditSpecificationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInstanceCreditSpecifications, request); } /** * An Async wrapper for DescribeInstanceCreditSpecifications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceCreditSpecificationsAsync(const DescribeInstanceCreditSpecificationsRequestT& request, const DescribeInstanceCreditSpecificationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInstanceCreditSpecifications, request, handler, context); } /** *

Describes the tag keys that are registered to appear in scheduled event * notifications for resources in the current Region.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceEventNotificationAttributesOutcome DescribeInstanceEventNotificationAttributes(const Model::DescribeInstanceEventNotificationAttributesRequest& request) const; /** * A Callable wrapper for DescribeInstanceEventNotificationAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceEventNotificationAttributesOutcomeCallable DescribeInstanceEventNotificationAttributesCallable(const DescribeInstanceEventNotificationAttributesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInstanceEventNotificationAttributes, request); } /** * An Async wrapper for DescribeInstanceEventNotificationAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceEventNotificationAttributesAsync(const DescribeInstanceEventNotificationAttributesRequestT& request, const DescribeInstanceEventNotificationAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInstanceEventNotificationAttributes, request, handler, context); } /** *

Describes the specified event windows or all event windows.

If you * specify event window IDs, the output includes information for only the specified * event windows. If you specify filters, the output includes information for only * those event windows that meet the filter criteria. If you do not specify event * windows IDs or filters, the output includes information for all event windows, * which can affect performance. We recommend that you use pagination to ensure * that the operation returns quickly and successfully.

For more * information, see Define * event windows for scheduled events in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceEventWindowsOutcome DescribeInstanceEventWindows(const Model::DescribeInstanceEventWindowsRequest& request) const; /** * A Callable wrapper for DescribeInstanceEventWindows that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceEventWindowsOutcomeCallable DescribeInstanceEventWindowsCallable(const DescribeInstanceEventWindowsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInstanceEventWindows, request); } /** * An Async wrapper for DescribeInstanceEventWindows that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceEventWindowsAsync(const DescribeInstanceEventWindowsRequestT& request, const DescribeInstanceEventWindowsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInstanceEventWindows, request, handler, context); } /** *

Describes the status of the specified instances or all of your instances. By * default, only running instances are described, unless you specifically indicate * to return the status of all instances.

Instance status includes the * following components:

  • Status checks - Amazon EC2 * performs status checks on running EC2 instances to identify hardware and * software issues. For more information, see Status * checks for your instances and Troubleshoot * instances with failed status checks in the Amazon EC2 User Guide.

    *

  • Scheduled events - Amazon EC2 can schedule events (such as * reboot, stop, or terminate) for your instances related to hardware issues, * software updates, or system maintenance. For more information, see Scheduled * events for your instances in the Amazon EC2 User Guide.

    • *

  • Instance state - You can manage your instances from the moment * you launch them through their termination. For more information, see Instance * lifecycle in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceStatusOutcome DescribeInstanceStatus(const Model::DescribeInstanceStatusRequest& request) const; /** * A Callable wrapper for DescribeInstanceStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceStatusOutcomeCallable DescribeInstanceStatusCallable(const DescribeInstanceStatusRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInstanceStatus, request); } /** * An Async wrapper for DescribeInstanceStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceStatusAsync(const DescribeInstanceStatusRequestT& request, const DescribeInstanceStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInstanceStatus, request, handler, context); } /** *

Returns a list of all instance types offered. The results can be filtered by * location (Region or Availability Zone). If no location is specified, the * instance types offered in the current Region are returned.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceTypeOfferingsOutcome DescribeInstanceTypeOfferings(const Model::DescribeInstanceTypeOfferingsRequest& request) const; /** * A Callable wrapper for DescribeInstanceTypeOfferings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceTypeOfferingsOutcomeCallable DescribeInstanceTypeOfferingsCallable(const DescribeInstanceTypeOfferingsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInstanceTypeOfferings, request); } /** * An Async wrapper for DescribeInstanceTypeOfferings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceTypeOfferingsAsync(const DescribeInstanceTypeOfferingsRequestT& request, const DescribeInstanceTypeOfferingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInstanceTypeOfferings, request, handler, context); } /** *

Describes the details of the instance types that are offered in a location. * The results can be filtered by the attributes of the instance * types.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstanceTypesOutcome DescribeInstanceTypes(const Model::DescribeInstanceTypesRequest& request) const; /** * A Callable wrapper for DescribeInstanceTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstanceTypesOutcomeCallable DescribeInstanceTypesCallable(const DescribeInstanceTypesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInstanceTypes, request); } /** * An Async wrapper for DescribeInstanceTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstanceTypesAsync(const DescribeInstanceTypesRequestT& request, const DescribeInstanceTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInstanceTypes, request, handler, context); } /** *

Describes the specified instances or all instances.

If you specify * instance IDs, the output includes information for only the specified instances. * If you specify filters, the output includes information for only those instances * that meet the filter criteria. If you do not specify instance IDs or filters, * the output includes information for all instances, which can affect performance. * We recommend that you use pagination to ensure that the operation returns * quickly and successfully.

If you specify an instance ID that is not * valid, an error is returned. If you specify an instance that you do not own, it * is not included in the output.

Recently terminated instances might appear * in the returned results. This interval is usually less than one hour.

If * you describe instances in the rare case where an Availability Zone is * experiencing a service disruption and you specify instance IDs that are in the * affected zone, or do not specify any instance IDs at all, the call fails. If you * describe instances and specify only instance IDs that are in an unaffected zone, * the call works normally.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInstancesOutcome DescribeInstances(const Model::DescribeInstancesRequest& request) const; /** * A Callable wrapper for DescribeInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInstancesOutcomeCallable DescribeInstancesCallable(const DescribeInstancesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInstances, request); } /** * An Async wrapper for DescribeInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInstancesAsync(const DescribeInstancesRequestT& request, const DescribeInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInstances, request, handler, context); } /** *

Describes one or more of your internet gateways.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeInternetGatewaysOutcome DescribeInternetGateways(const Model::DescribeInternetGatewaysRequest& request) const; /** * A Callable wrapper for DescribeInternetGateways that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInternetGatewaysOutcomeCallable DescribeInternetGatewaysCallable(const DescribeInternetGatewaysRequestT& request) const { return SubmitCallable(&EC2Client::DescribeInternetGateways, request); } /** * An Async wrapper for DescribeInternetGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInternetGatewaysAsync(const DescribeInternetGatewaysRequestT& request, const DescribeInternetGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeInternetGateways, request, handler, context); } /** *

Get information about your IPAM pools.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIpamPoolsOutcome DescribeIpamPools(const Model::DescribeIpamPoolsRequest& request) const; /** * A Callable wrapper for DescribeIpamPools that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIpamPoolsOutcomeCallable DescribeIpamPoolsCallable(const DescribeIpamPoolsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeIpamPools, request); } /** * An Async wrapper for DescribeIpamPools that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIpamPoolsAsync(const DescribeIpamPoolsRequestT& request, const DescribeIpamPoolsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeIpamPools, request, handler, context); } /** *

Describes IPAM resource discoveries. A resource discovery is an IPAM * component that enables IPAM to manage and monitor resources that belong to the * owning account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIpamResourceDiscoveriesOutcome DescribeIpamResourceDiscoveries(const Model::DescribeIpamResourceDiscoveriesRequest& request) const; /** * A Callable wrapper for DescribeIpamResourceDiscoveries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIpamResourceDiscoveriesOutcomeCallable DescribeIpamResourceDiscoveriesCallable(const DescribeIpamResourceDiscoveriesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeIpamResourceDiscoveries, request); } /** * An Async wrapper for DescribeIpamResourceDiscoveries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIpamResourceDiscoveriesAsync(const DescribeIpamResourceDiscoveriesRequestT& request, const DescribeIpamResourceDiscoveriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeIpamResourceDiscoveries, request, handler, context); } /** *

Describes resource discovery association with an Amazon VPC IPAM. An * associated resource discovery is a resource discovery that has been associated * with an IPAM..

See Also:

AWS * API Reference

*/ virtual Model::DescribeIpamResourceDiscoveryAssociationsOutcome DescribeIpamResourceDiscoveryAssociations(const Model::DescribeIpamResourceDiscoveryAssociationsRequest& request) const; /** * A Callable wrapper for DescribeIpamResourceDiscoveryAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIpamResourceDiscoveryAssociationsOutcomeCallable DescribeIpamResourceDiscoveryAssociationsCallable(const DescribeIpamResourceDiscoveryAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeIpamResourceDiscoveryAssociations, request); } /** * An Async wrapper for DescribeIpamResourceDiscoveryAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIpamResourceDiscoveryAssociationsAsync(const DescribeIpamResourceDiscoveryAssociationsRequestT& request, const DescribeIpamResourceDiscoveryAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeIpamResourceDiscoveryAssociations, request, handler, context); } /** *

Get information about your IPAM scopes.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIpamScopesOutcome DescribeIpamScopes(const Model::DescribeIpamScopesRequest& request) const; /** * A Callable wrapper for DescribeIpamScopes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIpamScopesOutcomeCallable DescribeIpamScopesCallable(const DescribeIpamScopesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeIpamScopes, request); } /** * An Async wrapper for DescribeIpamScopes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIpamScopesAsync(const DescribeIpamScopesRequestT& request, const DescribeIpamScopesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeIpamScopes, request, handler, context); } /** *

Get information about your IPAM pools.

For more information, see What is * IPAM? in the Amazon VPC IPAM User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeIpamsOutcome DescribeIpams(const Model::DescribeIpamsRequest& request) const; /** * A Callable wrapper for DescribeIpams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIpamsOutcomeCallable DescribeIpamsCallable(const DescribeIpamsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeIpams, request); } /** * An Async wrapper for DescribeIpams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIpamsAsync(const DescribeIpamsRequestT& request, const DescribeIpamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeIpams, request, handler, context); } /** *

Describes your IPv6 address pools.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIpv6PoolsOutcome DescribeIpv6Pools(const Model::DescribeIpv6PoolsRequest& request) const; /** * A Callable wrapper for DescribeIpv6Pools that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIpv6PoolsOutcomeCallable DescribeIpv6PoolsCallable(const DescribeIpv6PoolsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeIpv6Pools, request); } /** * An Async wrapper for DescribeIpv6Pools that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIpv6PoolsAsync(const DescribeIpv6PoolsRequestT& request, const DescribeIpv6PoolsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeIpv6Pools, request, handler, context); } /** *

Describes the specified key pairs or all of your key pairs.

For more * information about key pairs, see Amazon * EC2 key pairs in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeKeyPairsOutcome DescribeKeyPairs(const Model::DescribeKeyPairsRequest& request) const; /** * A Callable wrapper for DescribeKeyPairs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeKeyPairsOutcomeCallable DescribeKeyPairsCallable(const DescribeKeyPairsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeKeyPairs, request); } /** * An Async wrapper for DescribeKeyPairs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeKeyPairsAsync(const DescribeKeyPairsRequestT& request, const DescribeKeyPairsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeKeyPairs, request, handler, context); } /** *

Describes one or more versions of a specified launch template. You can * describe all versions, individual versions, or a range of versions. You can also * describe all the latest versions or all the default versions of all the launch * templates in your account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLaunchTemplateVersionsOutcome DescribeLaunchTemplateVersions(const Model::DescribeLaunchTemplateVersionsRequest& request) const; /** * A Callable wrapper for DescribeLaunchTemplateVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLaunchTemplateVersionsOutcomeCallable DescribeLaunchTemplateVersionsCallable(const DescribeLaunchTemplateVersionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeLaunchTemplateVersions, request); } /** * An Async wrapper for DescribeLaunchTemplateVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLaunchTemplateVersionsAsync(const DescribeLaunchTemplateVersionsRequestT& request, const DescribeLaunchTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeLaunchTemplateVersions, request, handler, context); } /** *

Describes one or more launch templates.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLaunchTemplatesOutcome DescribeLaunchTemplates(const Model::DescribeLaunchTemplatesRequest& request) const; /** * A Callable wrapper for DescribeLaunchTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLaunchTemplatesOutcomeCallable DescribeLaunchTemplatesCallable(const DescribeLaunchTemplatesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeLaunchTemplates, request); } /** * An Async wrapper for DescribeLaunchTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLaunchTemplatesAsync(const DescribeLaunchTemplatesRequestT& request, const DescribeLaunchTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeLaunchTemplates, request, handler, context); } /** *

Describes the associations between virtual interface groups and local gateway * route tables.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutcome DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(const Model::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest& request) const; /** * A Callable wrapper for DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutcomeCallable DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCallable(const DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations, request); } /** * An Async wrapper for DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsAsync(const DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequestT& request, const DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations, request, handler, context); } /** *

Describes the specified associations between VPCs and local gateway route * tables.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocalGatewayRouteTableVpcAssociationsOutcome DescribeLocalGatewayRouteTableVpcAssociations(const Model::DescribeLocalGatewayRouteTableVpcAssociationsRequest& request) const; /** * A Callable wrapper for DescribeLocalGatewayRouteTableVpcAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocalGatewayRouteTableVpcAssociationsOutcomeCallable DescribeLocalGatewayRouteTableVpcAssociationsCallable(const DescribeLocalGatewayRouteTableVpcAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeLocalGatewayRouteTableVpcAssociations, request); } /** * An Async wrapper for DescribeLocalGatewayRouteTableVpcAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocalGatewayRouteTableVpcAssociationsAsync(const DescribeLocalGatewayRouteTableVpcAssociationsRequestT& request, const DescribeLocalGatewayRouteTableVpcAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeLocalGatewayRouteTableVpcAssociations, request, handler, context); } /** *

Describes one or more local gateway route tables. By default, all local * gateway route tables are described. Alternatively, you can filter the * results.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLocalGatewayRouteTablesOutcome DescribeLocalGatewayRouteTables(const Model::DescribeLocalGatewayRouteTablesRequest& request) const; /** * A Callable wrapper for DescribeLocalGatewayRouteTables that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocalGatewayRouteTablesOutcomeCallable DescribeLocalGatewayRouteTablesCallable(const DescribeLocalGatewayRouteTablesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeLocalGatewayRouteTables, request); } /** * An Async wrapper for DescribeLocalGatewayRouteTables that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocalGatewayRouteTablesAsync(const DescribeLocalGatewayRouteTablesRequestT& request, const DescribeLocalGatewayRouteTablesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeLocalGatewayRouteTables, request, handler, context); } /** *

Describes the specified local gateway virtual interface groups.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeLocalGatewayVirtualInterfaceGroupsOutcome DescribeLocalGatewayVirtualInterfaceGroups(const Model::DescribeLocalGatewayVirtualInterfaceGroupsRequest& request) const; /** * A Callable wrapper for DescribeLocalGatewayVirtualInterfaceGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocalGatewayVirtualInterfaceGroupsOutcomeCallable DescribeLocalGatewayVirtualInterfaceGroupsCallable(const DescribeLocalGatewayVirtualInterfaceGroupsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeLocalGatewayVirtualInterfaceGroups, request); } /** * An Async wrapper for DescribeLocalGatewayVirtualInterfaceGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocalGatewayVirtualInterfaceGroupsAsync(const DescribeLocalGatewayVirtualInterfaceGroupsRequestT& request, const DescribeLocalGatewayVirtualInterfaceGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeLocalGatewayVirtualInterfaceGroups, request, handler, context); } /** *

Describes the specified local gateway virtual interfaces.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeLocalGatewayVirtualInterfacesOutcome DescribeLocalGatewayVirtualInterfaces(const Model::DescribeLocalGatewayVirtualInterfacesRequest& request) const; /** * A Callable wrapper for DescribeLocalGatewayVirtualInterfaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocalGatewayVirtualInterfacesOutcomeCallable DescribeLocalGatewayVirtualInterfacesCallable(const DescribeLocalGatewayVirtualInterfacesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeLocalGatewayVirtualInterfaces, request); } /** * An Async wrapper for DescribeLocalGatewayVirtualInterfaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocalGatewayVirtualInterfacesAsync(const DescribeLocalGatewayVirtualInterfacesRequestT& request, const DescribeLocalGatewayVirtualInterfacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeLocalGatewayVirtualInterfaces, request, handler, context); } /** *

Describes one or more local gateways. By default, all local gateways are * described. Alternatively, you can filter the results.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeLocalGatewaysOutcome DescribeLocalGateways(const Model::DescribeLocalGatewaysRequest& request) const; /** * A Callable wrapper for DescribeLocalGateways that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLocalGatewaysOutcomeCallable DescribeLocalGatewaysCallable(const DescribeLocalGatewaysRequestT& request) const { return SubmitCallable(&EC2Client::DescribeLocalGateways, request); } /** * An Async wrapper for DescribeLocalGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLocalGatewaysAsync(const DescribeLocalGatewaysRequestT& request, const DescribeLocalGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeLocalGateways, request, handler, context); } /** *

Describes your managed prefix lists and any Amazon Web Services-managed * prefix lists.

To view the entries for your prefix list, use * GetManagedPrefixListEntries.

See Also:

AWS * API Reference

*/ virtual Model::DescribeManagedPrefixListsOutcome DescribeManagedPrefixLists(const Model::DescribeManagedPrefixListsRequest& request) const; /** * A Callable wrapper for DescribeManagedPrefixLists that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeManagedPrefixListsOutcomeCallable DescribeManagedPrefixListsCallable(const DescribeManagedPrefixListsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeManagedPrefixLists, request); } /** * An Async wrapper for DescribeManagedPrefixLists that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeManagedPrefixListsAsync(const DescribeManagedPrefixListsRequestT& request, const DescribeManagedPrefixListsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeManagedPrefixLists, request, handler, context); } /** *

This action is deprecated.

Describes your Elastic IP * addresses that are being moved from or being restored to the EC2-Classic * platform. This request does not return information about any other Elastic IP * addresses in your account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMovingAddressesOutcome DescribeMovingAddresses(const Model::DescribeMovingAddressesRequest& request) const; /** * A Callable wrapper for DescribeMovingAddresses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMovingAddressesOutcomeCallable DescribeMovingAddressesCallable(const DescribeMovingAddressesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeMovingAddresses, request); } /** * An Async wrapper for DescribeMovingAddresses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMovingAddressesAsync(const DescribeMovingAddressesRequestT& request, const DescribeMovingAddressesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeMovingAddresses, request, handler, context); } /** *

Describes one or more of your NAT gateways.

See Also:

AWS * API Reference

*/ virtual Model::DescribeNatGatewaysOutcome DescribeNatGateways(const Model::DescribeNatGatewaysRequest& request) const; /** * A Callable wrapper for DescribeNatGateways that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNatGatewaysOutcomeCallable DescribeNatGatewaysCallable(const DescribeNatGatewaysRequestT& request) const { return SubmitCallable(&EC2Client::DescribeNatGateways, request); } /** * An Async wrapper for DescribeNatGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNatGatewaysAsync(const DescribeNatGatewaysRequestT& request, const DescribeNatGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeNatGateways, request, handler, context); } /** *

Describes one or more of your network ACLs.

For more information, see * Network * ACLs in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeNetworkAclsOutcome DescribeNetworkAcls(const Model::DescribeNetworkAclsRequest& request) const; /** * A Callable wrapper for DescribeNetworkAcls that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNetworkAclsOutcomeCallable DescribeNetworkAclsCallable(const DescribeNetworkAclsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeNetworkAcls, request); } /** * An Async wrapper for DescribeNetworkAcls that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNetworkAclsAsync(const DescribeNetworkAclsRequestT& request, const DescribeNetworkAclsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeNetworkAcls, request, handler, context); } /** *

Describes the specified Network Access Scope analyses.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeNetworkInsightsAccessScopeAnalysesOutcome DescribeNetworkInsightsAccessScopeAnalyses(const Model::DescribeNetworkInsightsAccessScopeAnalysesRequest& request) const; /** * A Callable wrapper for DescribeNetworkInsightsAccessScopeAnalyses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNetworkInsightsAccessScopeAnalysesOutcomeCallable DescribeNetworkInsightsAccessScopeAnalysesCallable(const DescribeNetworkInsightsAccessScopeAnalysesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeNetworkInsightsAccessScopeAnalyses, request); } /** * An Async wrapper for DescribeNetworkInsightsAccessScopeAnalyses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNetworkInsightsAccessScopeAnalysesAsync(const DescribeNetworkInsightsAccessScopeAnalysesRequestT& request, const DescribeNetworkInsightsAccessScopeAnalysesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeNetworkInsightsAccessScopeAnalyses, request, handler, context); } /** *

Describes the specified Network Access Scopes.

See Also:

AWS * API Reference

*/ virtual Model::DescribeNetworkInsightsAccessScopesOutcome DescribeNetworkInsightsAccessScopes(const Model::DescribeNetworkInsightsAccessScopesRequest& request) const; /** * A Callable wrapper for DescribeNetworkInsightsAccessScopes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNetworkInsightsAccessScopesOutcomeCallable DescribeNetworkInsightsAccessScopesCallable(const DescribeNetworkInsightsAccessScopesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeNetworkInsightsAccessScopes, request); } /** * An Async wrapper for DescribeNetworkInsightsAccessScopes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNetworkInsightsAccessScopesAsync(const DescribeNetworkInsightsAccessScopesRequestT& request, const DescribeNetworkInsightsAccessScopesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeNetworkInsightsAccessScopes, request, handler, context); } /** *

Describes one or more of your network insights analyses.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeNetworkInsightsAnalysesOutcome DescribeNetworkInsightsAnalyses(const Model::DescribeNetworkInsightsAnalysesRequest& request) const; /** * A Callable wrapper for DescribeNetworkInsightsAnalyses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNetworkInsightsAnalysesOutcomeCallable DescribeNetworkInsightsAnalysesCallable(const DescribeNetworkInsightsAnalysesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeNetworkInsightsAnalyses, request); } /** * An Async wrapper for DescribeNetworkInsightsAnalyses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNetworkInsightsAnalysesAsync(const DescribeNetworkInsightsAnalysesRequestT& request, const DescribeNetworkInsightsAnalysesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeNetworkInsightsAnalyses, request, handler, context); } /** *

Describes one or more of your paths.

See Also:

AWS * API Reference

*/ virtual Model::DescribeNetworkInsightsPathsOutcome DescribeNetworkInsightsPaths(const Model::DescribeNetworkInsightsPathsRequest& request) const; /** * A Callable wrapper for DescribeNetworkInsightsPaths that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNetworkInsightsPathsOutcomeCallable DescribeNetworkInsightsPathsCallable(const DescribeNetworkInsightsPathsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeNetworkInsightsPaths, request); } /** * An Async wrapper for DescribeNetworkInsightsPaths that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNetworkInsightsPathsAsync(const DescribeNetworkInsightsPathsRequestT& request, const DescribeNetworkInsightsPathsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeNetworkInsightsPaths, request, handler, context); } /** *

Describes a network interface attribute. You can specify only one attribute * at a time.

See Also:

AWS * API Reference

*/ virtual Model::DescribeNetworkInterfaceAttributeOutcome DescribeNetworkInterfaceAttribute(const Model::DescribeNetworkInterfaceAttributeRequest& request) const; /** * A Callable wrapper for DescribeNetworkInterfaceAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNetworkInterfaceAttributeOutcomeCallable DescribeNetworkInterfaceAttributeCallable(const DescribeNetworkInterfaceAttributeRequestT& request) const { return SubmitCallable(&EC2Client::DescribeNetworkInterfaceAttribute, request); } /** * An Async wrapper for DescribeNetworkInterfaceAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNetworkInterfaceAttributeAsync(const DescribeNetworkInterfaceAttributeRequestT& request, const DescribeNetworkInterfaceAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeNetworkInterfaceAttribute, request, handler, context); } /** *

Describes the permissions for your network interfaces.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeNetworkInterfacePermissionsOutcome DescribeNetworkInterfacePermissions(const Model::DescribeNetworkInterfacePermissionsRequest& request) const; /** * A Callable wrapper for DescribeNetworkInterfacePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNetworkInterfacePermissionsOutcomeCallable DescribeNetworkInterfacePermissionsCallable(const DescribeNetworkInterfacePermissionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeNetworkInterfacePermissions, request); } /** * An Async wrapper for DescribeNetworkInterfacePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNetworkInterfacePermissionsAsync(const DescribeNetworkInterfacePermissionsRequestT& request, const DescribeNetworkInterfacePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeNetworkInterfacePermissions, request, handler, context); } /** *

Describes one or more of your network interfaces.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeNetworkInterfacesOutcome DescribeNetworkInterfaces(const Model::DescribeNetworkInterfacesRequest& request) const; /** * A Callable wrapper for DescribeNetworkInterfaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNetworkInterfacesOutcomeCallable DescribeNetworkInterfacesCallable(const DescribeNetworkInterfacesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeNetworkInterfaces, request); } /** * An Async wrapper for DescribeNetworkInterfaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNetworkInterfacesAsync(const DescribeNetworkInterfacesRequestT& request, const DescribeNetworkInterfacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeNetworkInterfaces, request, handler, context); } /** *

Describes the specified placement groups or all of your placement groups. For * more information, see Placement * groups in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribePlacementGroupsOutcome DescribePlacementGroups(const Model::DescribePlacementGroupsRequest& request) const; /** * A Callable wrapper for DescribePlacementGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePlacementGroupsOutcomeCallable DescribePlacementGroupsCallable(const DescribePlacementGroupsRequestT& request) const { return SubmitCallable(&EC2Client::DescribePlacementGroups, request); } /** * An Async wrapper for DescribePlacementGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePlacementGroupsAsync(const DescribePlacementGroupsRequestT& request, const DescribePlacementGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribePlacementGroups, request, handler, context); } /** *

Describes available Amazon Web Services services in a prefix list format, * which includes the prefix list name and prefix list ID of the service and the IP * address range for the service.

We recommend that you use * DescribeManagedPrefixLists instead.

See Also:

AWS * API Reference

*/ virtual Model::DescribePrefixListsOutcome DescribePrefixLists(const Model::DescribePrefixListsRequest& request) const; /** * A Callable wrapper for DescribePrefixLists that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePrefixListsOutcomeCallable DescribePrefixListsCallable(const DescribePrefixListsRequestT& request) const { return SubmitCallable(&EC2Client::DescribePrefixLists, request); } /** * An Async wrapper for DescribePrefixLists that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePrefixListsAsync(const DescribePrefixListsRequestT& request, const DescribePrefixListsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribePrefixLists, request, handler, context); } /** *

Describes the ID format settings for the root user and all IAM roles and IAM * users that have explicitly specified a longer ID (17-character ID) preference. *

By default, all IAM roles and IAM users default to the same ID settings * as the root user, unless they explicitly override the settings. This request is * useful for identifying those IAM users and IAM roles that have overridden the * default ID settings.

The following resource types support longer IDs: * bundle | conversion-task | * customer-gateway | dhcp-options | * elastic-ip-allocation | elastic-ip-association | * export-task | flow-log | image | * import-task | instance | internet-gateway * | network-acl | network-acl-association | * network-interface | network-interface-attachment | * prefix-list | reservation | route-table | * route-table-association | security-group | * snapshot | subnet | * subnet-cidr-block-association | volume | * vpc | vpc-cidr-block-association | * vpc-endpoint | vpc-peering-connection | * vpn-connection | vpn-gateway.

See * Also:

AWS * API Reference

*/ virtual Model::DescribePrincipalIdFormatOutcome DescribePrincipalIdFormat(const Model::DescribePrincipalIdFormatRequest& request) const; /** * A Callable wrapper for DescribePrincipalIdFormat that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePrincipalIdFormatOutcomeCallable DescribePrincipalIdFormatCallable(const DescribePrincipalIdFormatRequestT& request) const { return SubmitCallable(&EC2Client::DescribePrincipalIdFormat, request); } /** * An Async wrapper for DescribePrincipalIdFormat that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePrincipalIdFormatAsync(const DescribePrincipalIdFormatRequestT& request, const DescribePrincipalIdFormatResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribePrincipalIdFormat, request, handler, context); } /** *

Describes the specified IPv4 address pools.

See Also:

AWS * API Reference

*/ virtual Model::DescribePublicIpv4PoolsOutcome DescribePublicIpv4Pools(const Model::DescribePublicIpv4PoolsRequest& request) const; /** * A Callable wrapper for DescribePublicIpv4Pools that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePublicIpv4PoolsOutcomeCallable DescribePublicIpv4PoolsCallable(const DescribePublicIpv4PoolsRequestT& request) const { return SubmitCallable(&EC2Client::DescribePublicIpv4Pools, request); } /** * An Async wrapper for DescribePublicIpv4Pools that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePublicIpv4PoolsAsync(const DescribePublicIpv4PoolsRequestT& request, const DescribePublicIpv4PoolsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribePublicIpv4Pools, request, handler, context); } /** *

Describes the Regions that are enabled for your account, or all Regions.

*

For a list of the Regions supported by Amazon EC2, see Amazon * Elastic Compute Cloud endpoints and quotas.

For information about * enabling and disabling Regions for your account, see Managing * Amazon Web Services Regions in the Amazon Web Services General * Reference.

See Also:

AWS * API Reference

*/ virtual Model::DescribeRegionsOutcome DescribeRegions(const Model::DescribeRegionsRequest& request) const; /** * A Callable wrapper for DescribeRegions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRegionsOutcomeCallable DescribeRegionsCallable(const DescribeRegionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeRegions, request); } /** * An Async wrapper for DescribeRegions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRegionsAsync(const DescribeRegionsRequestT& request, const DescribeRegionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeRegions, request, handler, context); } /** *

Describes a root volume replacement task. For more information, see Replace * a root volume in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReplaceRootVolumeTasksOutcome DescribeReplaceRootVolumeTasks(const Model::DescribeReplaceRootVolumeTasksRequest& request) const; /** * A Callable wrapper for DescribeReplaceRootVolumeTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReplaceRootVolumeTasksOutcomeCallable DescribeReplaceRootVolumeTasksCallable(const DescribeReplaceRootVolumeTasksRequestT& request) const { return SubmitCallable(&EC2Client::DescribeReplaceRootVolumeTasks, request); } /** * An Async wrapper for DescribeReplaceRootVolumeTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReplaceRootVolumeTasksAsync(const DescribeReplaceRootVolumeTasksRequestT& request, const DescribeReplaceRootVolumeTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeReplaceRootVolumeTasks, request, handler, context); } /** *

Describes one or more of the Reserved Instances that you purchased.

*

For more information about Reserved Instances, see Reserved * Instances in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReservedInstancesOutcome DescribeReservedInstances(const Model::DescribeReservedInstancesRequest& request) const; /** * A Callable wrapper for DescribeReservedInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedInstancesOutcomeCallable DescribeReservedInstancesCallable(const DescribeReservedInstancesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeReservedInstances, request); } /** * An Async wrapper for DescribeReservedInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedInstancesAsync(const DescribeReservedInstancesRequestT& request, const DescribeReservedInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeReservedInstances, request, handler, context); } /** *

Describes your account's Reserved Instance listings in the Reserved Instance * Marketplace.

The Reserved Instance Marketplace matches sellers who want * to resell Reserved Instance capacity that they no longer need with buyers who * want to purchase additional capacity. Reserved Instances bought and sold through * the Reserved Instance Marketplace work like any other Reserved Instances.

*

As a seller, you choose to list some or all of your Reserved Instances, and * you specify the upfront price to receive for them. Your Reserved Instances are * then listed in the Reserved Instance Marketplace and are available for * purchase.

As a buyer, you specify the configuration of the Reserved * Instance to purchase, and the Marketplace matches what you're searching for with * what's available. The Marketplace first sells the lowest priced Reserved * Instances to you, and continues to sell available Reserved Instance listings to * you until your demand is met. You are charged based on the total price of all of * the listings that you purchase.

For more information, see Reserved * Instance Marketplace in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeReservedInstancesListingsOutcome DescribeReservedInstancesListings(const Model::DescribeReservedInstancesListingsRequest& request) const; /** * A Callable wrapper for DescribeReservedInstancesListings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedInstancesListingsOutcomeCallable DescribeReservedInstancesListingsCallable(const DescribeReservedInstancesListingsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeReservedInstancesListings, request); } /** * An Async wrapper for DescribeReservedInstancesListings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedInstancesListingsAsync(const DescribeReservedInstancesListingsRequestT& request, const DescribeReservedInstancesListingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeReservedInstancesListings, request, handler, context); } /** *

Describes the modifications made to your Reserved Instances. If no parameter * is specified, information about all your Reserved Instances modification * requests is returned. If a modification ID is specified, only information about * the specific modification is returned.

For more information, see Modifying * Reserved Instances in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeReservedInstancesModificationsOutcome DescribeReservedInstancesModifications(const Model::DescribeReservedInstancesModificationsRequest& request) const; /** * A Callable wrapper for DescribeReservedInstancesModifications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedInstancesModificationsOutcomeCallable DescribeReservedInstancesModificationsCallable(const DescribeReservedInstancesModificationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeReservedInstancesModifications, request); } /** * An Async wrapper for DescribeReservedInstancesModifications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedInstancesModificationsAsync(const DescribeReservedInstancesModificationsRequestT& request, const DescribeReservedInstancesModificationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeReservedInstancesModifications, request, handler, context); } /** *

Describes Reserved Instance offerings that are available for purchase. With * Reserved Instances, you purchase the right to launch instances for a period of * time. During that time period, you do not receive insufficient capacity errors, * and you pay a lower usage rate than the rate charged for On-Demand instances for * the actual time used.

If you have listed your own Reserved Instances for * sale in the Reserved Instance Marketplace, they will be excluded from these * results. This is to ensure that you do not purchase your own Reserved * Instances.

For more information, see Reserved * Instance Marketplace in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeReservedInstancesOfferingsOutcome DescribeReservedInstancesOfferings(const Model::DescribeReservedInstancesOfferingsRequest& request) const; /** * A Callable wrapper for DescribeReservedInstancesOfferings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedInstancesOfferingsOutcomeCallable DescribeReservedInstancesOfferingsCallable(const DescribeReservedInstancesOfferingsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeReservedInstancesOfferings, request); } /** * An Async wrapper for DescribeReservedInstancesOfferings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedInstancesOfferingsAsync(const DescribeReservedInstancesOfferingsRequestT& request, const DescribeReservedInstancesOfferingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeReservedInstancesOfferings, request, handler, context); } /** *

Describes one or more of your route tables.

Each subnet in your VPC * must be associated with a route table. If a subnet is not explicitly associated * with any route table, it is implicitly associated with the main route table. * This command does not return the subnet ID for implicit associations.

For * more information, see Route * tables in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeRouteTablesOutcome DescribeRouteTables(const Model::DescribeRouteTablesRequest& request) const; /** * A Callable wrapper for DescribeRouteTables that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRouteTablesOutcomeCallable DescribeRouteTablesCallable(const DescribeRouteTablesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeRouteTables, request); } /** * An Async wrapper for DescribeRouteTables that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRouteTablesAsync(const DescribeRouteTablesRequestT& request, const DescribeRouteTablesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeRouteTables, request, handler, context); } /** *

Finds available schedules that meet the specified criteria.

You can * search for an available schedule no more than 3 months in advance. You must meet * the minimum required duration of 1,200 hours per year. For example, the minimum * daily schedule is 4 hours, the minimum weekly schedule is 24 hours, and the * minimum monthly schedule is 100 hours.

After you find a schedule that * meets your needs, call PurchaseScheduledInstances to purchase Scheduled * Instances with that schedule.

See Also:

AWS * API Reference

*/ virtual Model::DescribeScheduledInstanceAvailabilityOutcome DescribeScheduledInstanceAvailability(const Model::DescribeScheduledInstanceAvailabilityRequest& request) const; /** * A Callable wrapper for DescribeScheduledInstanceAvailability that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeScheduledInstanceAvailabilityOutcomeCallable DescribeScheduledInstanceAvailabilityCallable(const DescribeScheduledInstanceAvailabilityRequestT& request) const { return SubmitCallable(&EC2Client::DescribeScheduledInstanceAvailability, request); } /** * An Async wrapper for DescribeScheduledInstanceAvailability that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeScheduledInstanceAvailabilityAsync(const DescribeScheduledInstanceAvailabilityRequestT& request, const DescribeScheduledInstanceAvailabilityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeScheduledInstanceAvailability, request, handler, context); } /** *

Describes the specified Scheduled Instances or all your Scheduled * Instances.

See Also:

AWS * API Reference

*/ virtual Model::DescribeScheduledInstancesOutcome DescribeScheduledInstances(const Model::DescribeScheduledInstancesRequest& request) const; /** * A Callable wrapper for DescribeScheduledInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeScheduledInstancesOutcomeCallable DescribeScheduledInstancesCallable(const DescribeScheduledInstancesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeScheduledInstances, request); } /** * An Async wrapper for DescribeScheduledInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeScheduledInstancesAsync(const DescribeScheduledInstancesRequestT& request, const DescribeScheduledInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeScheduledInstances, request, handler, context); } /** *

Describes the VPCs on the other side of a VPC peering connection that are * referencing the security groups you've specified in this request.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeSecurityGroupReferencesOutcome DescribeSecurityGroupReferences(const Model::DescribeSecurityGroupReferencesRequest& request) const; /** * A Callable wrapper for DescribeSecurityGroupReferences that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSecurityGroupReferencesOutcomeCallable DescribeSecurityGroupReferencesCallable(const DescribeSecurityGroupReferencesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSecurityGroupReferences, request); } /** * An Async wrapper for DescribeSecurityGroupReferences that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSecurityGroupReferencesAsync(const DescribeSecurityGroupReferencesRequestT& request, const DescribeSecurityGroupReferencesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSecurityGroupReferences, request, handler, context); } /** *

Describes one or more of your security group rules.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeSecurityGroupRulesOutcome DescribeSecurityGroupRules(const Model::DescribeSecurityGroupRulesRequest& request) const; /** * A Callable wrapper for DescribeSecurityGroupRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSecurityGroupRulesOutcomeCallable DescribeSecurityGroupRulesCallable(const DescribeSecurityGroupRulesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSecurityGroupRules, request); } /** * An Async wrapper for DescribeSecurityGroupRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSecurityGroupRulesAsync(const DescribeSecurityGroupRulesRequestT& request, const DescribeSecurityGroupRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSecurityGroupRules, request, handler, context); } /** *

Describes the specified security groups or all of your security * groups.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSecurityGroupsOutcome DescribeSecurityGroups(const Model::DescribeSecurityGroupsRequest& request) const; /** * A Callable wrapper for DescribeSecurityGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSecurityGroupsOutcomeCallable DescribeSecurityGroupsCallable(const DescribeSecurityGroupsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSecurityGroups, request); } /** * An Async wrapper for DescribeSecurityGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSecurityGroupsAsync(const DescribeSecurityGroupsRequestT& request, const DescribeSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSecurityGroups, request, handler, context); } /** *

Describes the specified attribute of the specified snapshot. You can specify * only one attribute at a time.

For more information about EBS snapshots, * see Amazon * EBS snapshots in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSnapshotAttributeOutcome DescribeSnapshotAttribute(const Model::DescribeSnapshotAttributeRequest& request) const; /** * A Callable wrapper for DescribeSnapshotAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSnapshotAttributeOutcomeCallable DescribeSnapshotAttributeCallable(const DescribeSnapshotAttributeRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSnapshotAttribute, request); } /** * An Async wrapper for DescribeSnapshotAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSnapshotAttributeAsync(const DescribeSnapshotAttributeRequestT& request, const DescribeSnapshotAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSnapshotAttribute, request, handler, context); } /** *

Describes the storage tier status of one or more Amazon EBS * snapshots.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSnapshotTierStatusOutcome DescribeSnapshotTierStatus(const Model::DescribeSnapshotTierStatusRequest& request) const; /** * A Callable wrapper for DescribeSnapshotTierStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSnapshotTierStatusOutcomeCallable DescribeSnapshotTierStatusCallable(const DescribeSnapshotTierStatusRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSnapshotTierStatus, request); } /** * An Async wrapper for DescribeSnapshotTierStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSnapshotTierStatusAsync(const DescribeSnapshotTierStatusRequestT& request, const DescribeSnapshotTierStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSnapshotTierStatus, request, handler, context); } /** *

Describes the specified EBS snapshots available to you or all of the EBS * snapshots available to you.

The snapshots available to you include public * snapshots, private snapshots that you own, and private snapshots owned by other * Amazon Web Services accounts for which you have explicit create volume * permissions.

The create volume permissions fall into the following * categories:

  • public: The owner of the snapshot granted * create volume permissions for the snapshot to the all group. All * Amazon Web Services accounts have create volume permissions for these * snapshots.

  • explicit: The owner of the snapshot granted * create volume permissions to a specific Amazon Web Services account.

    • *

  • implicit: An Amazon Web Services account has implicit create * volume permissions for all snapshots it owns.

The list of * snapshots returned can be filtered by specifying snapshot IDs, snapshot owners, * or Amazon Web Services accounts with create volume permissions. If no options * are specified, Amazon EC2 returns all snapshots for which you have create volume * permissions.

If you specify one or more snapshot IDs, only snapshots that * have the specified IDs are returned. If you specify an invalid snapshot ID, an * error is returned. If you specify a snapshot ID for which you do not have * access, it is not included in the returned results.

If you specify one or * more snapshot owners using the OwnerIds option, only snapshots from * the specified owners and for which you have access are returned. The results can * include the Amazon Web Services account IDs of the specified owners, * amazon for snapshots owned by Amazon, or self for * snapshots that you own.

If you specify a list of restorable users, only * snapshots with create snapshot permissions for those users are returned. You can * specify Amazon Web Services account IDs (if you own the snapshots), * self for snapshots for which you own or have explicit permissions, * or all for public snapshots.

If you are describing a long * list of snapshots, we recommend that you paginate the output to make the list * more manageable. For more information, see Pagination.

*

To get the state of fast snapshot restores for a snapshot, use * DescribeFastSnapshotRestores.

For more information about EBS * snapshots, see Amazon * EBS snapshots in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSnapshotsOutcome DescribeSnapshots(const Model::DescribeSnapshotsRequest& request) const; /** * A Callable wrapper for DescribeSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSnapshotsOutcomeCallable DescribeSnapshotsCallable(const DescribeSnapshotsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSnapshots, request); } /** * An Async wrapper for DescribeSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSnapshotsAsync(const DescribeSnapshotsRequestT& request, const DescribeSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSnapshots, request, handler, context); } /** *

Describes the data feed for Spot Instances. For more information, see Spot * Instance data feed in the Amazon EC2 User Guide for Linux * Instances.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSpotDatafeedSubscriptionOutcome DescribeSpotDatafeedSubscription(const Model::DescribeSpotDatafeedSubscriptionRequest& request) const; /** * A Callable wrapper for DescribeSpotDatafeedSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSpotDatafeedSubscriptionOutcomeCallable DescribeSpotDatafeedSubscriptionCallable(const DescribeSpotDatafeedSubscriptionRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSpotDatafeedSubscription, request); } /** * An Async wrapper for DescribeSpotDatafeedSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSpotDatafeedSubscriptionAsync(const DescribeSpotDatafeedSubscriptionRequestT& request, const DescribeSpotDatafeedSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSpotDatafeedSubscription, request, handler, context); } /** *

Describes the running instances for the specified Spot Fleet.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeSpotFleetInstancesOutcome DescribeSpotFleetInstances(const Model::DescribeSpotFleetInstancesRequest& request) const; /** * A Callable wrapper for DescribeSpotFleetInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSpotFleetInstancesOutcomeCallable DescribeSpotFleetInstancesCallable(const DescribeSpotFleetInstancesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSpotFleetInstances, request); } /** * An Async wrapper for DescribeSpotFleetInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSpotFleetInstancesAsync(const DescribeSpotFleetInstancesRequestT& request, const DescribeSpotFleetInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSpotFleetInstances, request, handler, context); } /** *

Describes the events for the specified Spot Fleet request during the * specified time.

Spot Fleet events are delayed by up to 30 seconds before * they can be described. This ensures that you can query by the last evaluated * time and not miss a recorded event. Spot Fleet events are available for 48 * hours.

For more information, see Monitor * fleet events using Amazon EventBridge in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSpotFleetRequestHistoryOutcome DescribeSpotFleetRequestHistory(const Model::DescribeSpotFleetRequestHistoryRequest& request) const; /** * A Callable wrapper for DescribeSpotFleetRequestHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSpotFleetRequestHistoryOutcomeCallable DescribeSpotFleetRequestHistoryCallable(const DescribeSpotFleetRequestHistoryRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSpotFleetRequestHistory, request); } /** * An Async wrapper for DescribeSpotFleetRequestHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSpotFleetRequestHistoryAsync(const DescribeSpotFleetRequestHistoryRequestT& request, const DescribeSpotFleetRequestHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSpotFleetRequestHistory, request, handler, context); } /** *

Describes your Spot Fleet requests.

Spot Fleet requests are deleted 48 * hours after they are canceled and their instances are terminated.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeSpotFleetRequestsOutcome DescribeSpotFleetRequests(const Model::DescribeSpotFleetRequestsRequest& request) const; /** * A Callable wrapper for DescribeSpotFleetRequests that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSpotFleetRequestsOutcomeCallable DescribeSpotFleetRequestsCallable(const DescribeSpotFleetRequestsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSpotFleetRequests, request); } /** * An Async wrapper for DescribeSpotFleetRequests that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSpotFleetRequestsAsync(const DescribeSpotFleetRequestsRequestT& request, const DescribeSpotFleetRequestsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSpotFleetRequests, request, handler, context); } /** *

Describes the specified Spot Instance requests.

You can use * DescribeSpotInstanceRequests to find a running Spot Instance by * examining the response. If the status of the Spot Instance is * fulfilled, the instance ID appears in the response and contains the * identifier of the instance. Alternatively, you can use DescribeInstances * with a filter to look for instances where the instance lifecycle is * spot.

We recommend that you set MaxResults to a * value between 5 and 1000 to limit the number of items returned. This paginates * the output, which makes the list more manageable and returns the items faster. * If the list of items exceeds your MaxResults value, then that * number of items is returned along with a NextToken value that can * be passed to a subsequent DescribeSpotInstanceRequests request to * retrieve the remaining items.

Spot Instance requests are deleted four * hours after they are canceled and their instances are terminated.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeSpotInstanceRequestsOutcome DescribeSpotInstanceRequests(const Model::DescribeSpotInstanceRequestsRequest& request) const; /** * A Callable wrapper for DescribeSpotInstanceRequests that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSpotInstanceRequestsOutcomeCallable DescribeSpotInstanceRequestsCallable(const DescribeSpotInstanceRequestsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSpotInstanceRequests, request); } /** * An Async wrapper for DescribeSpotInstanceRequests that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSpotInstanceRequestsAsync(const DescribeSpotInstanceRequestsRequestT& request, const DescribeSpotInstanceRequestsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSpotInstanceRequests, request, handler, context); } /** *

Describes the Spot price history. For more information, see Spot * Instance pricing history in the Amazon EC2 User Guide for Linux * Instances.

When you specify a start and end time, the operation * returns the prices of the instance types within that time range. It also returns * the last price change before the start time, which is the effective price as of * the start time.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSpotPriceHistoryOutcome DescribeSpotPriceHistory(const Model::DescribeSpotPriceHistoryRequest& request) const; /** * A Callable wrapper for DescribeSpotPriceHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSpotPriceHistoryOutcomeCallable DescribeSpotPriceHistoryCallable(const DescribeSpotPriceHistoryRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSpotPriceHistory, request); } /** * An Async wrapper for DescribeSpotPriceHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSpotPriceHistoryAsync(const DescribeSpotPriceHistoryRequestT& request, const DescribeSpotPriceHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSpotPriceHistory, request, handler, context); } /** *

Describes the stale security group rules for security groups in a specified * VPC. Rules are stale when they reference a deleted security group in the same * VPC or in a peer VPC, or if they reference a security group in a peer VPC for * which the VPC peering connection has been deleted.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStaleSecurityGroupsOutcome DescribeStaleSecurityGroups(const Model::DescribeStaleSecurityGroupsRequest& request) const; /** * A Callable wrapper for DescribeStaleSecurityGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStaleSecurityGroupsOutcomeCallable DescribeStaleSecurityGroupsCallable(const DescribeStaleSecurityGroupsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeStaleSecurityGroups, request); } /** * An Async wrapper for DescribeStaleSecurityGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStaleSecurityGroupsAsync(const DescribeStaleSecurityGroupsRequestT& request, const DescribeStaleSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeStaleSecurityGroups, request, handler, context); } /** *

Describes the progress of the AMI store tasks. You can describe the store * tasks for specified AMIs. If you don't specify the AMIs, you get a paginated * list of store tasks from the last 31 days.

For each AMI task, the * response indicates if the task is InProgress, * Completed, or Failed. For tasks * InProgress, the response shows the estimated progress as a * percentage.

Tasks are listed in reverse chronological order. Currently, * only tasks from the past 31 days can be viewed.

To use this API, you must * have the required permissions. For more information, see Permissions * for storing and restoring AMIs using Amazon S3 in the Amazon EC2 User * Guide.

For more information, see Store * and restore an AMI using Amazon S3 in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStoreImageTasksOutcome DescribeStoreImageTasks(const Model::DescribeStoreImageTasksRequest& request) const; /** * A Callable wrapper for DescribeStoreImageTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStoreImageTasksOutcomeCallable DescribeStoreImageTasksCallable(const DescribeStoreImageTasksRequestT& request) const { return SubmitCallable(&EC2Client::DescribeStoreImageTasks, request); } /** * An Async wrapper for DescribeStoreImageTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStoreImageTasksAsync(const DescribeStoreImageTasksRequestT& request, const DescribeStoreImageTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeStoreImageTasks, request, handler, context); } /** *

Describes one or more of your subnets.

For more information, see Subnets * in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSubnetsOutcome DescribeSubnets(const Model::DescribeSubnetsRequest& request) const; /** * A Callable wrapper for DescribeSubnets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSubnetsOutcomeCallable DescribeSubnetsCallable(const DescribeSubnetsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeSubnets, request); } /** * An Async wrapper for DescribeSubnets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSubnetsAsync(const DescribeSubnetsRequestT& request, const DescribeSubnetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeSubnets, request, handler, context); } /** *

Describes the specified tags for your EC2 resources.

For more * information about tags, see Tag * your Amazon EC2 resources in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const; /** * A Callable wrapper for DescribeTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTags, request); } /** * An Async wrapper for DescribeTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTagsAsync(const DescribeTagsRequestT& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTags, request, handler, context); } /** *

Describes one or more Traffic Mirror filters.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTrafficMirrorFiltersOutcome DescribeTrafficMirrorFilters(const Model::DescribeTrafficMirrorFiltersRequest& request) const; /** * A Callable wrapper for DescribeTrafficMirrorFilters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTrafficMirrorFiltersOutcomeCallable DescribeTrafficMirrorFiltersCallable(const DescribeTrafficMirrorFiltersRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTrafficMirrorFilters, request); } /** * An Async wrapper for DescribeTrafficMirrorFilters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTrafficMirrorFiltersAsync(const DescribeTrafficMirrorFiltersRequestT& request, const DescribeTrafficMirrorFiltersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTrafficMirrorFilters, request, handler, context); } /** *

Describes one or more Traffic Mirror sessions. By default, all Traffic Mirror * sessions are described. Alternatively, you can filter the results.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeTrafficMirrorSessionsOutcome DescribeTrafficMirrorSessions(const Model::DescribeTrafficMirrorSessionsRequest& request) const; /** * A Callable wrapper for DescribeTrafficMirrorSessions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTrafficMirrorSessionsOutcomeCallable DescribeTrafficMirrorSessionsCallable(const DescribeTrafficMirrorSessionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTrafficMirrorSessions, request); } /** * An Async wrapper for DescribeTrafficMirrorSessions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTrafficMirrorSessionsAsync(const DescribeTrafficMirrorSessionsRequestT& request, const DescribeTrafficMirrorSessionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTrafficMirrorSessions, request, handler, context); } /** *

Information about one or more Traffic Mirror targets.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeTrafficMirrorTargetsOutcome DescribeTrafficMirrorTargets(const Model::DescribeTrafficMirrorTargetsRequest& request) const; /** * A Callable wrapper for DescribeTrafficMirrorTargets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTrafficMirrorTargetsOutcomeCallable DescribeTrafficMirrorTargetsCallable(const DescribeTrafficMirrorTargetsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTrafficMirrorTargets, request); } /** * An Async wrapper for DescribeTrafficMirrorTargets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTrafficMirrorTargetsAsync(const DescribeTrafficMirrorTargetsRequestT& request, const DescribeTrafficMirrorTargetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTrafficMirrorTargets, request, handler, context); } /** *

Describes one or more attachments between resources and transit gateways. By * default, all attachments are described. Alternatively, you can filter the * results by attachment ID, attachment state, resource ID, or resource * owner.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTransitGatewayAttachmentsOutcome DescribeTransitGatewayAttachments(const Model::DescribeTransitGatewayAttachmentsRequest& request) const; /** * A Callable wrapper for DescribeTransitGatewayAttachments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewayAttachmentsOutcomeCallable DescribeTransitGatewayAttachmentsCallable(const DescribeTransitGatewayAttachmentsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGatewayAttachments, request); } /** * An Async wrapper for DescribeTransitGatewayAttachments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewayAttachmentsAsync(const DescribeTransitGatewayAttachmentsRequestT& request, const DescribeTransitGatewayAttachmentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGatewayAttachments, request, handler, context); } /** *

Describes one or more Connect peers.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTransitGatewayConnectPeersOutcome DescribeTransitGatewayConnectPeers(const Model::DescribeTransitGatewayConnectPeersRequest& request) const; /** * A Callable wrapper for DescribeTransitGatewayConnectPeers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewayConnectPeersOutcomeCallable DescribeTransitGatewayConnectPeersCallable(const DescribeTransitGatewayConnectPeersRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGatewayConnectPeers, request); } /** * An Async wrapper for DescribeTransitGatewayConnectPeers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewayConnectPeersAsync(const DescribeTransitGatewayConnectPeersRequestT& request, const DescribeTransitGatewayConnectPeersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGatewayConnectPeers, request, handler, context); } /** *

Describes one or more Connect attachments.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTransitGatewayConnectsOutcome DescribeTransitGatewayConnects(const Model::DescribeTransitGatewayConnectsRequest& request) const; /** * A Callable wrapper for DescribeTransitGatewayConnects that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewayConnectsOutcomeCallable DescribeTransitGatewayConnectsCallable(const DescribeTransitGatewayConnectsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGatewayConnects, request); } /** * An Async wrapper for DescribeTransitGatewayConnects that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewayConnectsAsync(const DescribeTransitGatewayConnectsRequestT& request, const DescribeTransitGatewayConnectsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGatewayConnects, request, handler, context); } /** *

Describes one or more transit gateway multicast domains.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeTransitGatewayMulticastDomainsOutcome DescribeTransitGatewayMulticastDomains(const Model::DescribeTransitGatewayMulticastDomainsRequest& request) const; /** * A Callable wrapper for DescribeTransitGatewayMulticastDomains that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewayMulticastDomainsOutcomeCallable DescribeTransitGatewayMulticastDomainsCallable(const DescribeTransitGatewayMulticastDomainsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGatewayMulticastDomains, request); } /** * An Async wrapper for DescribeTransitGatewayMulticastDomains that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewayMulticastDomainsAsync(const DescribeTransitGatewayMulticastDomainsRequestT& request, const DescribeTransitGatewayMulticastDomainsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGatewayMulticastDomains, request, handler, context); } /** *

Describes your transit gateway peering attachments.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeTransitGatewayPeeringAttachmentsOutcome DescribeTransitGatewayPeeringAttachments(const Model::DescribeTransitGatewayPeeringAttachmentsRequest& request) const; /** * A Callable wrapper for DescribeTransitGatewayPeeringAttachments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewayPeeringAttachmentsOutcomeCallable DescribeTransitGatewayPeeringAttachmentsCallable(const DescribeTransitGatewayPeeringAttachmentsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGatewayPeeringAttachments, request); } /** * An Async wrapper for DescribeTransitGatewayPeeringAttachments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewayPeeringAttachmentsAsync(const DescribeTransitGatewayPeeringAttachmentsRequestT& request, const DescribeTransitGatewayPeeringAttachmentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGatewayPeeringAttachments, request, handler, context); } /** *

Describes one or more transit gateway route policy tables.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeTransitGatewayPolicyTablesOutcome DescribeTransitGatewayPolicyTables(const Model::DescribeTransitGatewayPolicyTablesRequest& request) const; /** * A Callable wrapper for DescribeTransitGatewayPolicyTables that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewayPolicyTablesOutcomeCallable DescribeTransitGatewayPolicyTablesCallable(const DescribeTransitGatewayPolicyTablesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGatewayPolicyTables, request); } /** * An Async wrapper for DescribeTransitGatewayPolicyTables that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewayPolicyTablesAsync(const DescribeTransitGatewayPolicyTablesRequestT& request, const DescribeTransitGatewayPolicyTablesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGatewayPolicyTables, request, handler, context); } /** *

Describes one or more transit gateway route table * advertisements.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTransitGatewayRouteTableAnnouncementsOutcome DescribeTransitGatewayRouteTableAnnouncements(const Model::DescribeTransitGatewayRouteTableAnnouncementsRequest& request) const; /** * A Callable wrapper for DescribeTransitGatewayRouteTableAnnouncements that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewayRouteTableAnnouncementsOutcomeCallable DescribeTransitGatewayRouteTableAnnouncementsCallable(const DescribeTransitGatewayRouteTableAnnouncementsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGatewayRouteTableAnnouncements, request); } /** * An Async wrapper for DescribeTransitGatewayRouteTableAnnouncements that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewayRouteTableAnnouncementsAsync(const DescribeTransitGatewayRouteTableAnnouncementsRequestT& request, const DescribeTransitGatewayRouteTableAnnouncementsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGatewayRouteTableAnnouncements, request, handler, context); } /** *

Describes one or more transit gateway route tables. By default, all transit * gateway route tables are described. Alternatively, you can filter the * results.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTransitGatewayRouteTablesOutcome DescribeTransitGatewayRouteTables(const Model::DescribeTransitGatewayRouteTablesRequest& request) const; /** * A Callable wrapper for DescribeTransitGatewayRouteTables that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewayRouteTablesOutcomeCallable DescribeTransitGatewayRouteTablesCallable(const DescribeTransitGatewayRouteTablesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGatewayRouteTables, request); } /** * An Async wrapper for DescribeTransitGatewayRouteTables that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewayRouteTablesAsync(const DescribeTransitGatewayRouteTablesRequestT& request, const DescribeTransitGatewayRouteTablesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGatewayRouteTables, request, handler, context); } /** *

Describes one or more VPC attachments. By default, all VPC attachments are * described. Alternatively, you can filter the results.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeTransitGatewayVpcAttachmentsOutcome DescribeTransitGatewayVpcAttachments(const Model::DescribeTransitGatewayVpcAttachmentsRequest& request) const; /** * A Callable wrapper for DescribeTransitGatewayVpcAttachments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewayVpcAttachmentsOutcomeCallable DescribeTransitGatewayVpcAttachmentsCallable(const DescribeTransitGatewayVpcAttachmentsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGatewayVpcAttachments, request); } /** * An Async wrapper for DescribeTransitGatewayVpcAttachments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewayVpcAttachmentsAsync(const DescribeTransitGatewayVpcAttachmentsRequestT& request, const DescribeTransitGatewayVpcAttachmentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGatewayVpcAttachments, request, handler, context); } /** *

Describes one or more transit gateways. By default, all transit gateways are * described. Alternatively, you can filter the results.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeTransitGatewaysOutcome DescribeTransitGateways(const Model::DescribeTransitGatewaysRequest& request) const; /** * A Callable wrapper for DescribeTransitGateways that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransitGatewaysOutcomeCallable DescribeTransitGatewaysCallable(const DescribeTransitGatewaysRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTransitGateways, request); } /** * An Async wrapper for DescribeTransitGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransitGatewaysAsync(const DescribeTransitGatewaysRequestT& request, const DescribeTransitGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTransitGateways, request, handler, context); } /** *

This API action is currently in limited preview only. If you * are interested in using this feature, contact your account manager.

*

Describes one or more network interface trunk associations.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeTrunkInterfaceAssociationsOutcome DescribeTrunkInterfaceAssociations(const Model::DescribeTrunkInterfaceAssociationsRequest& request) const; /** * A Callable wrapper for DescribeTrunkInterfaceAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTrunkInterfaceAssociationsOutcomeCallable DescribeTrunkInterfaceAssociationsCallable(const DescribeTrunkInterfaceAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeTrunkInterfaceAssociations, request); } /** * An Async wrapper for DescribeTrunkInterfaceAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTrunkInterfaceAssociationsAsync(const DescribeTrunkInterfaceAssociationsRequestT& request, const DescribeTrunkInterfaceAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeTrunkInterfaceAssociations, request, handler, context); } /** *

Describes the specified Amazon Web Services Verified Access * endpoints.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVerifiedAccessEndpointsOutcome DescribeVerifiedAccessEndpoints(const Model::DescribeVerifiedAccessEndpointsRequest& request) const; /** * A Callable wrapper for DescribeVerifiedAccessEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVerifiedAccessEndpointsOutcomeCallable DescribeVerifiedAccessEndpointsCallable(const DescribeVerifiedAccessEndpointsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVerifiedAccessEndpoints, request); } /** * An Async wrapper for DescribeVerifiedAccessEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVerifiedAccessEndpointsAsync(const DescribeVerifiedAccessEndpointsRequestT& request, const DescribeVerifiedAccessEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVerifiedAccessEndpoints, request, handler, context); } /** *

Describes the specified Verified Access groups.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVerifiedAccessGroupsOutcome DescribeVerifiedAccessGroups(const Model::DescribeVerifiedAccessGroupsRequest& request) const; /** * A Callable wrapper for DescribeVerifiedAccessGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVerifiedAccessGroupsOutcomeCallable DescribeVerifiedAccessGroupsCallable(const DescribeVerifiedAccessGroupsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVerifiedAccessGroups, request); } /** * An Async wrapper for DescribeVerifiedAccessGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVerifiedAccessGroupsAsync(const DescribeVerifiedAccessGroupsRequestT& request, const DescribeVerifiedAccessGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVerifiedAccessGroups, request, handler, context); } /** *

Describes the specified Amazon Web Services Verified Access * instances.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVerifiedAccessInstanceLoggingConfigurationsOutcome DescribeVerifiedAccessInstanceLoggingConfigurations(const Model::DescribeVerifiedAccessInstanceLoggingConfigurationsRequest& request) const; /** * A Callable wrapper for DescribeVerifiedAccessInstanceLoggingConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVerifiedAccessInstanceLoggingConfigurationsOutcomeCallable DescribeVerifiedAccessInstanceLoggingConfigurationsCallable(const DescribeVerifiedAccessInstanceLoggingConfigurationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVerifiedAccessInstanceLoggingConfigurations, request); } /** * An Async wrapper for DescribeVerifiedAccessInstanceLoggingConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVerifiedAccessInstanceLoggingConfigurationsAsync(const DescribeVerifiedAccessInstanceLoggingConfigurationsRequestT& request, const DescribeVerifiedAccessInstanceLoggingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVerifiedAccessInstanceLoggingConfigurations, request, handler, context); } /** *

Describes the specified Amazon Web Services Verified Access * instances.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVerifiedAccessInstancesOutcome DescribeVerifiedAccessInstances(const Model::DescribeVerifiedAccessInstancesRequest& request) const; /** * A Callable wrapper for DescribeVerifiedAccessInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVerifiedAccessInstancesOutcomeCallable DescribeVerifiedAccessInstancesCallable(const DescribeVerifiedAccessInstancesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVerifiedAccessInstances, request); } /** * An Async wrapper for DescribeVerifiedAccessInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVerifiedAccessInstancesAsync(const DescribeVerifiedAccessInstancesRequestT& request, const DescribeVerifiedAccessInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVerifiedAccessInstances, request, handler, context); } /** *

Describes the specified Amazon Web Services Verified Access trust * providers.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVerifiedAccessTrustProvidersOutcome DescribeVerifiedAccessTrustProviders(const Model::DescribeVerifiedAccessTrustProvidersRequest& request) const; /** * A Callable wrapper for DescribeVerifiedAccessTrustProviders that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVerifiedAccessTrustProvidersOutcomeCallable DescribeVerifiedAccessTrustProvidersCallable(const DescribeVerifiedAccessTrustProvidersRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVerifiedAccessTrustProviders, request); } /** * An Async wrapper for DescribeVerifiedAccessTrustProviders that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVerifiedAccessTrustProvidersAsync(const DescribeVerifiedAccessTrustProvidersRequestT& request, const DescribeVerifiedAccessTrustProvidersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVerifiedAccessTrustProviders, request, handler, context); } /** *

Describes the specified attribute of the specified volume. You can specify * only one attribute at a time.

For more information about EBS volumes, see * Amazon * EBS volumes in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVolumeAttributeOutcome DescribeVolumeAttribute(const Model::DescribeVolumeAttributeRequest& request) const; /** * A Callable wrapper for DescribeVolumeAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVolumeAttributeOutcomeCallable DescribeVolumeAttributeCallable(const DescribeVolumeAttributeRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVolumeAttribute, request); } /** * An Async wrapper for DescribeVolumeAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVolumeAttributeAsync(const DescribeVolumeAttributeRequestT& request, const DescribeVolumeAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVolumeAttribute, request, handler, context); } /** *

Describes the status of the specified volumes. Volume status provides the * result of the checks performed on your volumes to determine events that can * impair the performance of your volumes. The performance of a volume can be * affected if an issue occurs on the volume's underlying host. If the volume's * underlying host experiences a power outage or system issue, after the system is * restored, there could be data inconsistencies on the volume. Volume events * notify you if this occurs. Volume actions notify you if any action needs to be * taken in response to the event.

The DescribeVolumeStatus * operation provides the following information about the specified volumes:

*

Status: Reflects the current status of the volume. The possible * values are ok, impaired , warning, or * insufficient-data. If all checks pass, the overall status of the * volume is ok. If the check fails, the overall status is * impaired. If the status is insufficient-data, then the * checks might still be taking place on your volume at the time. We recommend that * you retry the request. For more information about volume status, see Monitor * the status of your volumes in the Amazon Elastic Compute Cloud User * Guide.

Events: Reflect the cause of a volume status and might * require you to take action. For example, if your volume returns an * impaired status, then the volume event might be * potential-data-inconsistency. This means that your volume has been * affected by an issue with the underlying host, has all I/O operations disabled, * and might have inconsistent data.

Actions: Reflect the actions * you might have to take in response to an event. For example, if the status of * the volume is impaired and the volume event shows * potential-data-inconsistency, then the action shows * enable-volume-io. This means that you may want to enable the I/O * operations for the volume by calling the EnableVolumeIO action and then * check the volume for data consistency.

Volume status is based on the * volume status checks, and does not reflect the volume state. Therefore, volume * status does not indicate volumes in the error state (for example, * when a volume is incapable of accepting I/O.)

See Also:

AWS * API Reference

*/ virtual Model::DescribeVolumeStatusOutcome DescribeVolumeStatus(const Model::DescribeVolumeStatusRequest& request) const; /** * A Callable wrapper for DescribeVolumeStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVolumeStatusOutcomeCallable DescribeVolumeStatusCallable(const DescribeVolumeStatusRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVolumeStatus, request); } /** * An Async wrapper for DescribeVolumeStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVolumeStatusAsync(const DescribeVolumeStatusRequestT& request, const DescribeVolumeStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVolumeStatus, request, handler, context); } /** *

Describes the specified EBS volumes or all of your EBS volumes.

If you * are describing a long list of volumes, we recommend that you paginate the output * to make the list more manageable. For more information, see Pagination.

*

For more information about EBS volumes, see Amazon * EBS volumes in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVolumesOutcome DescribeVolumes(const Model::DescribeVolumesRequest& request) const; /** * A Callable wrapper for DescribeVolumes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVolumesOutcomeCallable DescribeVolumesCallable(const DescribeVolumesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVolumes, request); } /** * An Async wrapper for DescribeVolumes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVolumesAsync(const DescribeVolumesRequestT& request, const DescribeVolumesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVolumes, request, handler, context); } /** *

Describes the most recent volume modification request for the specified EBS * volumes.

If a volume has never been modified, some information in the * output will be null. If a volume has been modified more than once, the output * includes only the most recent modification request.

You can also use * CloudWatch Events to check the status of a modification to an EBS volume. For * information about CloudWatch Events, see the Amazon * CloudWatch Events User Guide. For more information, see Monitor * the progress of volume modifications in the Amazon Elastic Compute Cloud * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVolumesModificationsOutcome DescribeVolumesModifications(const Model::DescribeVolumesModificationsRequest& request) const; /** * A Callable wrapper for DescribeVolumesModifications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVolumesModificationsOutcomeCallable DescribeVolumesModificationsCallable(const DescribeVolumesModificationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVolumesModifications, request); } /** * An Async wrapper for DescribeVolumesModifications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVolumesModificationsAsync(const DescribeVolumesModificationsRequestT& request, const DescribeVolumesModificationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVolumesModifications, request, handler, context); } /** *

Describes the specified attribute of the specified VPC. You can specify only * one attribute at a time.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpcAttributeOutcome DescribeVpcAttribute(const Model::DescribeVpcAttributeRequest& request) const; /** * A Callable wrapper for DescribeVpcAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcAttributeOutcomeCallable DescribeVpcAttributeCallable(const DescribeVpcAttributeRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcAttribute, request); } /** * An Async wrapper for DescribeVpcAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcAttributeAsync(const DescribeVpcAttributeRequestT& request, const DescribeVpcAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcAttribute, request, handler, context); } /** *

This action is deprecated.

Describes the ClassicLink * status of the specified VPCs.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpcClassicLinkOutcome DescribeVpcClassicLink(const Model::DescribeVpcClassicLinkRequest& request) const; /** * A Callable wrapper for DescribeVpcClassicLink that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcClassicLinkOutcomeCallable DescribeVpcClassicLinkCallable(const DescribeVpcClassicLinkRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcClassicLink, request); } /** * An Async wrapper for DescribeVpcClassicLink that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcClassicLinkAsync(const DescribeVpcClassicLinkRequestT& request, const DescribeVpcClassicLinkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcClassicLink, request, handler, context); } /** *

This action is deprecated.

Describes the ClassicLink * DNS support status of one or more VPCs. If enabled, the DNS hostname of a linked * EC2-Classic instance resolves to its private IP address when addressed from an * instance in the VPC to which it's linked. Similarly, the DNS hostname of an * instance in a VPC resolves to its private IP address when addressed from a * linked EC2-Classic instance.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpcClassicLinkDnsSupportOutcome DescribeVpcClassicLinkDnsSupport(const Model::DescribeVpcClassicLinkDnsSupportRequest& request) const; /** * A Callable wrapper for DescribeVpcClassicLinkDnsSupport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcClassicLinkDnsSupportOutcomeCallable DescribeVpcClassicLinkDnsSupportCallable(const DescribeVpcClassicLinkDnsSupportRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcClassicLinkDnsSupport, request); } /** * An Async wrapper for DescribeVpcClassicLinkDnsSupport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcClassicLinkDnsSupportAsync(const DescribeVpcClassicLinkDnsSupportRequestT& request, const DescribeVpcClassicLinkDnsSupportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcClassicLinkDnsSupport, request, handler, context); } /** *

Describes the connection notifications for VPC endpoints and VPC endpoint * services.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpcEndpointConnectionNotificationsOutcome DescribeVpcEndpointConnectionNotifications(const Model::DescribeVpcEndpointConnectionNotificationsRequest& request) const; /** * A Callable wrapper for DescribeVpcEndpointConnectionNotifications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcEndpointConnectionNotificationsOutcomeCallable DescribeVpcEndpointConnectionNotificationsCallable(const DescribeVpcEndpointConnectionNotificationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcEndpointConnectionNotifications, request); } /** * An Async wrapper for DescribeVpcEndpointConnectionNotifications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcEndpointConnectionNotificationsAsync(const DescribeVpcEndpointConnectionNotificationsRequestT& request, const DescribeVpcEndpointConnectionNotificationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcEndpointConnectionNotifications, request, handler, context); } /** *

Describes the VPC endpoint connections to your VPC endpoint services, * including any endpoints that are pending your acceptance.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeVpcEndpointConnectionsOutcome DescribeVpcEndpointConnections(const Model::DescribeVpcEndpointConnectionsRequest& request) const; /** * A Callable wrapper for DescribeVpcEndpointConnections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcEndpointConnectionsOutcomeCallable DescribeVpcEndpointConnectionsCallable(const DescribeVpcEndpointConnectionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcEndpointConnections, request); } /** * An Async wrapper for DescribeVpcEndpointConnections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcEndpointConnectionsAsync(const DescribeVpcEndpointConnectionsRequestT& request, const DescribeVpcEndpointConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcEndpointConnections, request, handler, context); } /** *

Describes the VPC endpoint service configurations in your account (your * services).

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpcEndpointServiceConfigurationsOutcome DescribeVpcEndpointServiceConfigurations(const Model::DescribeVpcEndpointServiceConfigurationsRequest& request) const; /** * A Callable wrapper for DescribeVpcEndpointServiceConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcEndpointServiceConfigurationsOutcomeCallable DescribeVpcEndpointServiceConfigurationsCallable(const DescribeVpcEndpointServiceConfigurationsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcEndpointServiceConfigurations, request); } /** * An Async wrapper for DescribeVpcEndpointServiceConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcEndpointServiceConfigurationsAsync(const DescribeVpcEndpointServiceConfigurationsRequestT& request, const DescribeVpcEndpointServiceConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcEndpointServiceConfigurations, request, handler, context); } /** *

Describes the principals (service consumers) that are permitted to discover * your VPC endpoint service.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpcEndpointServicePermissionsOutcome DescribeVpcEndpointServicePermissions(const Model::DescribeVpcEndpointServicePermissionsRequest& request) const; /** * A Callable wrapper for DescribeVpcEndpointServicePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcEndpointServicePermissionsOutcomeCallable DescribeVpcEndpointServicePermissionsCallable(const DescribeVpcEndpointServicePermissionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcEndpointServicePermissions, request); } /** * An Async wrapper for DescribeVpcEndpointServicePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcEndpointServicePermissionsAsync(const DescribeVpcEndpointServicePermissionsRequestT& request, const DescribeVpcEndpointServicePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcEndpointServicePermissions, request, handler, context); } /** *

Describes available services to which you can create a VPC endpoint.

*

When the service provider and the consumer have different accounts in * multiple Availability Zones, and the consumer views the VPC endpoint service * information, the response only includes the common Availability Zones. For * example, when the service provider account uses us-east-1a and * us-east-1c and the consumer uses us-east-1a and * us-east-1b, the response includes the VPC endpoint services in the * common Availability Zone, us-east-1a.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpcEndpointServicesOutcome DescribeVpcEndpointServices(const Model::DescribeVpcEndpointServicesRequest& request) const; /** * A Callable wrapper for DescribeVpcEndpointServices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcEndpointServicesOutcomeCallable DescribeVpcEndpointServicesCallable(const DescribeVpcEndpointServicesRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcEndpointServices, request); } /** * An Async wrapper for DescribeVpcEndpointServices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcEndpointServicesAsync(const DescribeVpcEndpointServicesRequestT& request, const DescribeVpcEndpointServicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcEndpointServices, request, handler, context); } /** *

Describes your VPC endpoints.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpcEndpointsOutcome DescribeVpcEndpoints(const Model::DescribeVpcEndpointsRequest& request) const; /** * A Callable wrapper for DescribeVpcEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcEndpointsOutcomeCallable DescribeVpcEndpointsCallable(const DescribeVpcEndpointsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcEndpoints, request); } /** * An Async wrapper for DescribeVpcEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcEndpointsAsync(const DescribeVpcEndpointsRequestT& request, const DescribeVpcEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcEndpoints, request, handler, context); } /** *

Describes one or more of your VPC peering connections.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeVpcPeeringConnectionsOutcome DescribeVpcPeeringConnections(const Model::DescribeVpcPeeringConnectionsRequest& request) const; /** * A Callable wrapper for DescribeVpcPeeringConnections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcPeeringConnectionsOutcomeCallable DescribeVpcPeeringConnectionsCallable(const DescribeVpcPeeringConnectionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcPeeringConnections, request); } /** * An Async wrapper for DescribeVpcPeeringConnections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcPeeringConnectionsAsync(const DescribeVpcPeeringConnectionsRequestT& request, const DescribeVpcPeeringConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcPeeringConnections, request, handler, context); } /** *

Describes one or more of your VPCs.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpcsOutcome DescribeVpcs(const Model::DescribeVpcsRequest& request) const; /** * A Callable wrapper for DescribeVpcs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpcsOutcomeCallable DescribeVpcsCallable(const DescribeVpcsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpcs, request); } /** * An Async wrapper for DescribeVpcs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpcsAsync(const DescribeVpcsRequestT& request, const DescribeVpcsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpcs, request, handler, context); } /** *

Describes one or more of your VPN connections.

For more information, * see Amazon * Web Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpnConnectionsOutcome DescribeVpnConnections(const Model::DescribeVpnConnectionsRequest& request) const; /** * A Callable wrapper for DescribeVpnConnections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpnConnectionsOutcomeCallable DescribeVpnConnectionsCallable(const DescribeVpnConnectionsRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpnConnections, request); } /** * An Async wrapper for DescribeVpnConnections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpnConnectionsAsync(const DescribeVpnConnectionsRequestT& request, const DescribeVpnConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpnConnections, request, handler, context); } /** *

Describes one or more of your virtual private gateways.

For more * information, see Amazon Web * Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVpnGatewaysOutcome DescribeVpnGateways(const Model::DescribeVpnGatewaysRequest& request) const; /** * A Callable wrapper for DescribeVpnGateways that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVpnGatewaysOutcomeCallable DescribeVpnGatewaysCallable(const DescribeVpnGatewaysRequestT& request) const { return SubmitCallable(&EC2Client::DescribeVpnGateways, request); } /** * An Async wrapper for DescribeVpnGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVpnGatewaysAsync(const DescribeVpnGatewaysRequestT& request, const DescribeVpnGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DescribeVpnGateways, request, handler, context); } /** *

This action is deprecated.

Unlinks (detaches) a linked * EC2-Classic instance from a VPC. After the instance has been unlinked, the VPC * security groups are no longer associated with it. An instance is automatically * unlinked from a VPC when it's stopped.

See Also:

AWS * API Reference

*/ virtual Model::DetachClassicLinkVpcOutcome DetachClassicLinkVpc(const Model::DetachClassicLinkVpcRequest& request) const; /** * A Callable wrapper for DetachClassicLinkVpc that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachClassicLinkVpcOutcomeCallable DetachClassicLinkVpcCallable(const DetachClassicLinkVpcRequestT& request) const { return SubmitCallable(&EC2Client::DetachClassicLinkVpc, request); } /** * An Async wrapper for DetachClassicLinkVpc that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachClassicLinkVpcAsync(const DetachClassicLinkVpcRequestT& request, const DetachClassicLinkVpcResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DetachClassicLinkVpc, request, handler, context); } /** *

Detaches an internet gateway from a VPC, disabling connectivity between the * internet and the VPC. The VPC must not contain any running instances with * Elastic IP addresses or public IPv4 addresses.

See Also:

AWS * API Reference

*/ virtual Model::DetachInternetGatewayOutcome DetachInternetGateway(const Model::DetachInternetGatewayRequest& request) const; /** * A Callable wrapper for DetachInternetGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachInternetGatewayOutcomeCallable DetachInternetGatewayCallable(const DetachInternetGatewayRequestT& request) const { return SubmitCallable(&EC2Client::DetachInternetGateway, request); } /** * An Async wrapper for DetachInternetGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachInternetGatewayAsync(const DetachInternetGatewayRequestT& request, const DetachInternetGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DetachInternetGateway, request, handler, context); } /** *

Detaches a network interface from an instance.

See Also:

AWS * API Reference

*/ virtual Model::DetachNetworkInterfaceOutcome DetachNetworkInterface(const Model::DetachNetworkInterfaceRequest& request) const; /** * A Callable wrapper for DetachNetworkInterface that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachNetworkInterfaceOutcomeCallable DetachNetworkInterfaceCallable(const DetachNetworkInterfaceRequestT& request) const { return SubmitCallable(&EC2Client::DetachNetworkInterface, request); } /** * An Async wrapper for DetachNetworkInterface that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachNetworkInterfaceAsync(const DetachNetworkInterfaceRequestT& request, const DetachNetworkInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DetachNetworkInterface, request, handler, context); } /** *

Detaches the specified Amazon Web Services Verified Access trust provider * from the specified Amazon Web Services Verified Access instance.

See * Also:

AWS * API Reference

*/ virtual Model::DetachVerifiedAccessTrustProviderOutcome DetachVerifiedAccessTrustProvider(const Model::DetachVerifiedAccessTrustProviderRequest& request) const; /** * A Callable wrapper for DetachVerifiedAccessTrustProvider that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachVerifiedAccessTrustProviderOutcomeCallable DetachVerifiedAccessTrustProviderCallable(const DetachVerifiedAccessTrustProviderRequestT& request) const { return SubmitCallable(&EC2Client::DetachVerifiedAccessTrustProvider, request); } /** * An Async wrapper for DetachVerifiedAccessTrustProvider that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachVerifiedAccessTrustProviderAsync(const DetachVerifiedAccessTrustProviderRequestT& request, const DetachVerifiedAccessTrustProviderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DetachVerifiedAccessTrustProvider, request, handler, context); } /** *

Detaches an EBS volume from an instance. Make sure to unmount any file * systems on the device within your operating system before detaching the volume. * Failure to do so can result in the volume becoming stuck in the * busy state while detaching. If this happens, detachment can be * delayed indefinitely until you unmount the volume, force detachment, reboot the * instance, or all three. If an EBS volume is the root device of an instance, it * can't be detached while the instance is running. To detach the root volume, stop * the instance first.

When a volume with an Amazon Web Services Marketplace * product code is detached from an instance, the product code is no longer * associated with the instance.

For more information, see Detach * an Amazon EBS volume in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DetachVolumeOutcome DetachVolume(const Model::DetachVolumeRequest& request) const; /** * A Callable wrapper for DetachVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachVolumeOutcomeCallable DetachVolumeCallable(const DetachVolumeRequestT& request) const { return SubmitCallable(&EC2Client::DetachVolume, request); } /** * An Async wrapper for DetachVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachVolumeAsync(const DetachVolumeRequestT& request, const DetachVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DetachVolume, request, handler, context); } /** *

Detaches a virtual private gateway from a VPC. You do this if you're planning * to turn off the VPC and not use it anymore. You can confirm a virtual private * gateway has been completely detached from a VPC by describing the virtual * private gateway (any attachments to the virtual private gateway are also * described).

You must wait for the attachment's state to switch to * detached before you can delete the VPC or attach a different VPC to * the virtual private gateway.

See Also:

AWS * API Reference

*/ virtual Model::DetachVpnGatewayOutcome DetachVpnGateway(const Model::DetachVpnGatewayRequest& request) const; /** * A Callable wrapper for DetachVpnGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachVpnGatewayOutcomeCallable DetachVpnGatewayCallable(const DetachVpnGatewayRequestT& request) const { return SubmitCallable(&EC2Client::DetachVpnGateway, request); } /** * An Async wrapper for DetachVpnGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachVpnGatewayAsync(const DetachVpnGatewayRequestT& request, const DetachVpnGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DetachVpnGateway, request, handler, context); } /** *

Disables Elastic IP address transfer. For more information, see Transfer * Elastic IP addresses in the Amazon Virtual Private Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DisableAddressTransferOutcome DisableAddressTransfer(const Model::DisableAddressTransferRequest& request) const; /** * A Callable wrapper for DisableAddressTransfer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableAddressTransferOutcomeCallable DisableAddressTransferCallable(const DisableAddressTransferRequestT& request) const { return SubmitCallable(&EC2Client::DisableAddressTransfer, request); } /** * An Async wrapper for DisableAddressTransfer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableAddressTransferAsync(const DisableAddressTransferRequestT& request, const DisableAddressTransferResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableAddressTransfer, request, handler, context); } /** *

Disables Infrastructure Performance metric subscriptions.

See * Also:

AWS * API Reference

*/ virtual Model::DisableAwsNetworkPerformanceMetricSubscriptionOutcome DisableAwsNetworkPerformanceMetricSubscription(const Model::DisableAwsNetworkPerformanceMetricSubscriptionRequest& request) const; /** * A Callable wrapper for DisableAwsNetworkPerformanceMetricSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableAwsNetworkPerformanceMetricSubscriptionOutcomeCallable DisableAwsNetworkPerformanceMetricSubscriptionCallable(const DisableAwsNetworkPerformanceMetricSubscriptionRequestT& request) const { return SubmitCallable(&EC2Client::DisableAwsNetworkPerformanceMetricSubscription, request); } /** * An Async wrapper for DisableAwsNetworkPerformanceMetricSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableAwsNetworkPerformanceMetricSubscriptionAsync(const DisableAwsNetworkPerformanceMetricSubscriptionRequestT& request, const DisableAwsNetworkPerformanceMetricSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableAwsNetworkPerformanceMetricSubscription, request, handler, context); } /** *

Disables EBS encryption by default for your account in the current * Region.

After you disable encryption by default, you can still create * encrypted volumes by enabling encryption when you create each volume.

*

Disabling encryption by default does not change the encryption status of your * existing volumes.

For more information, see Amazon * EBS encryption in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DisableEbsEncryptionByDefaultOutcome DisableEbsEncryptionByDefault(const Model::DisableEbsEncryptionByDefaultRequest& request) const; /** * A Callable wrapper for DisableEbsEncryptionByDefault that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableEbsEncryptionByDefaultOutcomeCallable DisableEbsEncryptionByDefaultCallable(const DisableEbsEncryptionByDefaultRequestT& request) const { return SubmitCallable(&EC2Client::DisableEbsEncryptionByDefault, request); } /** * An Async wrapper for DisableEbsEncryptionByDefault that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableEbsEncryptionByDefaultAsync(const DisableEbsEncryptionByDefaultRequestT& request, const DisableEbsEncryptionByDefaultResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableEbsEncryptionByDefault, request, handler, context); } /** *

Discontinue faster launching for a Windows AMI, and clean up existing * pre-provisioned snapshots. When you disable faster launching, the AMI uses the * standard launch process for each instance. All pre-provisioned snapshots must be * removed before you can enable faster launching again.

To change * these settings, you must own the AMI.

See Also:

AWS * API Reference

*/ virtual Model::DisableFastLaunchOutcome DisableFastLaunch(const Model::DisableFastLaunchRequest& request) const; /** * A Callable wrapper for DisableFastLaunch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableFastLaunchOutcomeCallable DisableFastLaunchCallable(const DisableFastLaunchRequestT& request) const { return SubmitCallable(&EC2Client::DisableFastLaunch, request); } /** * An Async wrapper for DisableFastLaunch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableFastLaunchAsync(const DisableFastLaunchRequestT& request, const DisableFastLaunchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableFastLaunch, request, handler, context); } /** *

Disables fast snapshot restores for the specified snapshots in the specified * Availability Zones.

See Also:

AWS * API Reference

*/ virtual Model::DisableFastSnapshotRestoresOutcome DisableFastSnapshotRestores(const Model::DisableFastSnapshotRestoresRequest& request) const; /** * A Callable wrapper for DisableFastSnapshotRestores that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableFastSnapshotRestoresOutcomeCallable DisableFastSnapshotRestoresCallable(const DisableFastSnapshotRestoresRequestT& request) const { return SubmitCallable(&EC2Client::DisableFastSnapshotRestores, request); } /** * An Async wrapper for DisableFastSnapshotRestores that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableFastSnapshotRestoresAsync(const DisableFastSnapshotRestoresRequestT& request, const DisableFastSnapshotRestoresResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableFastSnapshotRestores, request, handler, context); } /** *

Cancels the deprecation of the specified AMI.

For more information, * see Deprecate * an AMI in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DisableImageDeprecationOutcome DisableImageDeprecation(const Model::DisableImageDeprecationRequest& request) const; /** * A Callable wrapper for DisableImageDeprecation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableImageDeprecationOutcomeCallable DisableImageDeprecationCallable(const DisableImageDeprecationRequestT& request) const { return SubmitCallable(&EC2Client::DisableImageDeprecation, request); } /** * An Async wrapper for DisableImageDeprecation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableImageDeprecationAsync(const DisableImageDeprecationRequestT& request, const DisableImageDeprecationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableImageDeprecation, request, handler, context); } /** *

Disable the IPAM account. For more information, see Enable * integration with Organizations in the Amazon VPC IPAM User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::DisableIpamOrganizationAdminAccountOutcome DisableIpamOrganizationAdminAccount(const Model::DisableIpamOrganizationAdminAccountRequest& request) const; /** * A Callable wrapper for DisableIpamOrganizationAdminAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableIpamOrganizationAdminAccountOutcomeCallable DisableIpamOrganizationAdminAccountCallable(const DisableIpamOrganizationAdminAccountRequestT& request) const { return SubmitCallable(&EC2Client::DisableIpamOrganizationAdminAccount, request); } /** * An Async wrapper for DisableIpamOrganizationAdminAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableIpamOrganizationAdminAccountAsync(const DisableIpamOrganizationAdminAccountRequestT& request, const DisableIpamOrganizationAdminAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableIpamOrganizationAdminAccount, request, handler, context); } /** *

Disables access to the EC2 serial console of all instances for your account. * By default, access to the EC2 serial console is disabled for your account. For * more information, see Manage * account access to the EC2 serial console in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DisableSerialConsoleAccessOutcome DisableSerialConsoleAccess(const Model::DisableSerialConsoleAccessRequest& request) const; /** * A Callable wrapper for DisableSerialConsoleAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableSerialConsoleAccessOutcomeCallable DisableSerialConsoleAccessCallable(const DisableSerialConsoleAccessRequestT& request) const { return SubmitCallable(&EC2Client::DisableSerialConsoleAccess, request); } /** * An Async wrapper for DisableSerialConsoleAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableSerialConsoleAccessAsync(const DisableSerialConsoleAccessRequestT& request, const DisableSerialConsoleAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableSerialConsoleAccess, request, handler, context); } /** *

Disables the specified resource attachment from propagating routes to the * specified propagation route table.

See Also:

AWS * API Reference

*/ virtual Model::DisableTransitGatewayRouteTablePropagationOutcome DisableTransitGatewayRouteTablePropagation(const Model::DisableTransitGatewayRouteTablePropagationRequest& request) const; /** * A Callable wrapper for DisableTransitGatewayRouteTablePropagation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableTransitGatewayRouteTablePropagationOutcomeCallable DisableTransitGatewayRouteTablePropagationCallable(const DisableTransitGatewayRouteTablePropagationRequestT& request) const { return SubmitCallable(&EC2Client::DisableTransitGatewayRouteTablePropagation, request); } /** * An Async wrapper for DisableTransitGatewayRouteTablePropagation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableTransitGatewayRouteTablePropagationAsync(const DisableTransitGatewayRouteTablePropagationRequestT& request, const DisableTransitGatewayRouteTablePropagationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableTransitGatewayRouteTablePropagation, request, handler, context); } /** *

Disables a virtual private gateway (VGW) from propagating routes to a * specified route table of a VPC.

See Also:

AWS * API Reference

*/ virtual Model::DisableVgwRoutePropagationOutcome DisableVgwRoutePropagation(const Model::DisableVgwRoutePropagationRequest& request) const; /** * A Callable wrapper for DisableVgwRoutePropagation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableVgwRoutePropagationOutcomeCallable DisableVgwRoutePropagationCallable(const DisableVgwRoutePropagationRequestT& request) const { return SubmitCallable(&EC2Client::DisableVgwRoutePropagation, request); } /** * An Async wrapper for DisableVgwRoutePropagation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableVgwRoutePropagationAsync(const DisableVgwRoutePropagationRequestT& request, const DisableVgwRoutePropagationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableVgwRoutePropagation, request, handler, context); } /** *

This action is deprecated.

Disables ClassicLink for a * VPC. You cannot disable ClassicLink for a VPC that has EC2-Classic instances * linked to it.

See Also:

AWS * API Reference

*/ virtual Model::DisableVpcClassicLinkOutcome DisableVpcClassicLink(const Model::DisableVpcClassicLinkRequest& request) const; /** * A Callable wrapper for DisableVpcClassicLink that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableVpcClassicLinkOutcomeCallable DisableVpcClassicLinkCallable(const DisableVpcClassicLinkRequestT& request) const { return SubmitCallable(&EC2Client::DisableVpcClassicLink, request); } /** * An Async wrapper for DisableVpcClassicLink that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableVpcClassicLinkAsync(const DisableVpcClassicLinkRequestT& request, const DisableVpcClassicLinkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableVpcClassicLink, request, handler, context); } /** *

This action is deprecated.

Disables ClassicLink DNS * support for a VPC. If disabled, DNS hostnames resolve to public IP addresses * when addressed between a linked EC2-Classic instance and instances in the VPC to * which it's linked.

You must specify a VPC ID in the * request.

See Also:

AWS * API Reference

*/ virtual Model::DisableVpcClassicLinkDnsSupportOutcome DisableVpcClassicLinkDnsSupport(const Model::DisableVpcClassicLinkDnsSupportRequest& request) const; /** * A Callable wrapper for DisableVpcClassicLinkDnsSupport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableVpcClassicLinkDnsSupportOutcomeCallable DisableVpcClassicLinkDnsSupportCallable(const DisableVpcClassicLinkDnsSupportRequestT& request) const { return SubmitCallable(&EC2Client::DisableVpcClassicLinkDnsSupport, request); } /** * An Async wrapper for DisableVpcClassicLinkDnsSupport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableVpcClassicLinkDnsSupportAsync(const DisableVpcClassicLinkDnsSupportRequestT& request, const DisableVpcClassicLinkDnsSupportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisableVpcClassicLinkDnsSupport, request, handler, context); } /** *

Disassociates an Elastic IP address from the instance or network interface * it's associated with.

This is an idempotent operation. If you perform the * operation more than once, Amazon EC2 doesn't return an error.

See * Also:

AWS * API Reference

*/ virtual Model::DisassociateAddressOutcome DisassociateAddress(const Model::DisassociateAddressRequest& request) const; /** * A Callable wrapper for DisassociateAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateAddressOutcomeCallable DisassociateAddressCallable(const DisassociateAddressRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateAddress, request); } /** * An Async wrapper for DisassociateAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateAddressAsync(const DisassociateAddressRequestT& request, const DisassociateAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateAddress, request, handler, context); } /** *

Disassociates a target network from the specified Client VPN endpoint. When * you disassociate the last target network from a Client VPN, the following * happens:

  • The route that was automatically added for the VPC is * deleted

  • All active client connections are terminated

    • *

  • New client connections are disallowed

  • The Client VPN * endpoint's status changes to pending-associate

    • *

See Also:

AWS * API Reference

*/ virtual Model::DisassociateClientVpnTargetNetworkOutcome DisassociateClientVpnTargetNetwork(const Model::DisassociateClientVpnTargetNetworkRequest& request) const; /** * A Callable wrapper for DisassociateClientVpnTargetNetwork that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateClientVpnTargetNetworkOutcomeCallable DisassociateClientVpnTargetNetworkCallable(const DisassociateClientVpnTargetNetworkRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateClientVpnTargetNetwork, request); } /** * An Async wrapper for DisassociateClientVpnTargetNetwork that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateClientVpnTargetNetworkAsync(const DisassociateClientVpnTargetNetworkRequestT& request, const DisassociateClientVpnTargetNetworkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateClientVpnTargetNetwork, request, handler, context); } /** *

Disassociates an IAM role from an Certificate Manager (ACM) certificate. * Disassociating an IAM role from an ACM certificate removes the Amazon S3 object * that contains the certificate, certificate chain, and encrypted private key from * the Amazon S3 bucket. It also revokes the IAM role's permission to use the KMS * key used to encrypt the private key. This effectively revokes the role's * permission to use the certificate.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateEnclaveCertificateIamRoleOutcome DisassociateEnclaveCertificateIamRole(const Model::DisassociateEnclaveCertificateIamRoleRequest& request) const; /** * A Callable wrapper for DisassociateEnclaveCertificateIamRole that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateEnclaveCertificateIamRoleOutcomeCallable DisassociateEnclaveCertificateIamRoleCallable(const DisassociateEnclaveCertificateIamRoleRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateEnclaveCertificateIamRole, request); } /** * An Async wrapper for DisassociateEnclaveCertificateIamRole that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateEnclaveCertificateIamRoleAsync(const DisassociateEnclaveCertificateIamRoleRequestT& request, const DisassociateEnclaveCertificateIamRoleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateEnclaveCertificateIamRole, request, handler, context); } /** *

Disassociates an IAM instance profile from a running or stopped instance.

*

Use DescribeIamInstanceProfileAssociations to get the association * ID.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateIamInstanceProfileOutcome DisassociateIamInstanceProfile(const Model::DisassociateIamInstanceProfileRequest& request) const; /** * A Callable wrapper for DisassociateIamInstanceProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateIamInstanceProfileOutcomeCallable DisassociateIamInstanceProfileCallable(const DisassociateIamInstanceProfileRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateIamInstanceProfile, request); } /** * An Async wrapper for DisassociateIamInstanceProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateIamInstanceProfileAsync(const DisassociateIamInstanceProfileRequestT& request, const DisassociateIamInstanceProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateIamInstanceProfile, request, handler, context); } /** *

Disassociates one or more targets from an event window.

For more * information, see Define * event windows for scheduled events in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateInstanceEventWindowOutcome DisassociateInstanceEventWindow(const Model::DisassociateInstanceEventWindowRequest& request) const; /** * A Callable wrapper for DisassociateInstanceEventWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateInstanceEventWindowOutcomeCallable DisassociateInstanceEventWindowCallable(const DisassociateInstanceEventWindowRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateInstanceEventWindow, request); } /** * An Async wrapper for DisassociateInstanceEventWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateInstanceEventWindowAsync(const DisassociateInstanceEventWindowRequestT& request, const DisassociateInstanceEventWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateInstanceEventWindow, request, handler, context); } /** *

Disassociates a resource discovery from an Amazon VPC IPAM. A resource * discovery is an IPAM component that enables IPAM to manage and monitor resources * that belong to the owning account.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateIpamResourceDiscoveryOutcome DisassociateIpamResourceDiscovery(const Model::DisassociateIpamResourceDiscoveryRequest& request) const; /** * A Callable wrapper for DisassociateIpamResourceDiscovery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateIpamResourceDiscoveryOutcomeCallable DisassociateIpamResourceDiscoveryCallable(const DisassociateIpamResourceDiscoveryRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateIpamResourceDiscovery, request); } /** * An Async wrapper for DisassociateIpamResourceDiscovery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateIpamResourceDiscoveryAsync(const DisassociateIpamResourceDiscoveryRequestT& request, const DisassociateIpamResourceDiscoveryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateIpamResourceDiscovery, request, handler, context); } /** *

Disassociates secondary Elastic IP addresses (EIPs) from a public NAT * gateway. You cannot disassociate your primary EIP. For more information, see Edit * secondary IP address associations in the Amazon VPC User Guide.

*

While disassociating is in progress, you cannot associate/disassociate * additional EIPs while the connections are being drained. You are, however, * allowed to delete the NAT gateway.

An EIP is released only at the end of * MaxDrainDurationSeconds. It stays associated and supports the existing * connections but does not support any new connections (new connections are * distributed across the remaining associated EIPs). As the existing connections * drain out, the EIPs (and the corresponding private IP addresses mapped to them) * are released.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateNatGatewayAddressOutcome DisassociateNatGatewayAddress(const Model::DisassociateNatGatewayAddressRequest& request) const; /** * A Callable wrapper for DisassociateNatGatewayAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateNatGatewayAddressOutcomeCallable DisassociateNatGatewayAddressCallable(const DisassociateNatGatewayAddressRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateNatGatewayAddress, request); } /** * An Async wrapper for DisassociateNatGatewayAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateNatGatewayAddressAsync(const DisassociateNatGatewayAddressRequestT& request, const DisassociateNatGatewayAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateNatGatewayAddress, request, handler, context); } /** *

Disassociates a subnet or gateway from a route table.

After you * perform this action, the subnet no longer uses the routes in the route table. * Instead, it uses the routes in the VPC's main route table. For more information * about route tables, see Route * tables in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateRouteTableOutcome DisassociateRouteTable(const Model::DisassociateRouteTableRequest& request) const; /** * A Callable wrapper for DisassociateRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateRouteTableOutcomeCallable DisassociateRouteTableCallable(const DisassociateRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateRouteTable, request); } /** * An Async wrapper for DisassociateRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateRouteTableAsync(const DisassociateRouteTableRequestT& request, const DisassociateRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateRouteTable, request, handler, context); } /** *

Disassociates a CIDR block from a subnet. Currently, you can disassociate an * IPv6 CIDR block only. You must detach or delete all gateways and resources that * are associated with the CIDR block before you can disassociate it. *

See Also:

AWS * API Reference

*/ virtual Model::DisassociateSubnetCidrBlockOutcome DisassociateSubnetCidrBlock(const Model::DisassociateSubnetCidrBlockRequest& request) const; /** * A Callable wrapper for DisassociateSubnetCidrBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateSubnetCidrBlockOutcomeCallable DisassociateSubnetCidrBlockCallable(const DisassociateSubnetCidrBlockRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateSubnetCidrBlock, request); } /** * An Async wrapper for DisassociateSubnetCidrBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateSubnetCidrBlockAsync(const DisassociateSubnetCidrBlockRequestT& request, const DisassociateSubnetCidrBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateSubnetCidrBlock, request, handler, context); } /** *

Disassociates the specified subnets from the transit gateway multicast * domain.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateTransitGatewayMulticastDomainOutcome DisassociateTransitGatewayMulticastDomain(const Model::DisassociateTransitGatewayMulticastDomainRequest& request) const; /** * A Callable wrapper for DisassociateTransitGatewayMulticastDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateTransitGatewayMulticastDomainOutcomeCallable DisassociateTransitGatewayMulticastDomainCallable(const DisassociateTransitGatewayMulticastDomainRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateTransitGatewayMulticastDomain, request); } /** * An Async wrapper for DisassociateTransitGatewayMulticastDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateTransitGatewayMulticastDomainAsync(const DisassociateTransitGatewayMulticastDomainRequestT& request, const DisassociateTransitGatewayMulticastDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateTransitGatewayMulticastDomain, request, handler, context); } /** *

Removes the association between an an attachment and a policy * table.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateTransitGatewayPolicyTableOutcome DisassociateTransitGatewayPolicyTable(const Model::DisassociateTransitGatewayPolicyTableRequest& request) const; /** * A Callable wrapper for DisassociateTransitGatewayPolicyTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateTransitGatewayPolicyTableOutcomeCallable DisassociateTransitGatewayPolicyTableCallable(const DisassociateTransitGatewayPolicyTableRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateTransitGatewayPolicyTable, request); } /** * An Async wrapper for DisassociateTransitGatewayPolicyTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateTransitGatewayPolicyTableAsync(const DisassociateTransitGatewayPolicyTableRequestT& request, const DisassociateTransitGatewayPolicyTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateTransitGatewayPolicyTable, request, handler, context); } /** *

Disassociates a resource attachment from a transit gateway route * table.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateTransitGatewayRouteTableOutcome DisassociateTransitGatewayRouteTable(const Model::DisassociateTransitGatewayRouteTableRequest& request) const; /** * A Callable wrapper for DisassociateTransitGatewayRouteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateTransitGatewayRouteTableOutcomeCallable DisassociateTransitGatewayRouteTableCallable(const DisassociateTransitGatewayRouteTableRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateTransitGatewayRouteTable, request); } /** * An Async wrapper for DisassociateTransitGatewayRouteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateTransitGatewayRouteTableAsync(const DisassociateTransitGatewayRouteTableRequestT& request, const DisassociateTransitGatewayRouteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateTransitGatewayRouteTable, request, handler, context); } /** *

This API action is currently in limited preview only. If you * are interested in using this feature, contact your account manager.

*

Removes an association between a branch network interface with a trunk * network interface.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateTrunkInterfaceOutcome DisassociateTrunkInterface(const Model::DisassociateTrunkInterfaceRequest& request) const; /** * A Callable wrapper for DisassociateTrunkInterface that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateTrunkInterfaceOutcomeCallable DisassociateTrunkInterfaceCallable(const DisassociateTrunkInterfaceRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateTrunkInterface, request); } /** * An Async wrapper for DisassociateTrunkInterface that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateTrunkInterfaceAsync(const DisassociateTrunkInterfaceRequestT& request, const DisassociateTrunkInterfaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateTrunkInterface, request, handler, context); } /** *

Disassociates a CIDR block from a VPC. To disassociate the CIDR block, you * must specify its association ID. You can get the association ID by using * DescribeVpcs. You must detach or delete all gateways and resources that * are associated with the CIDR block before you can disassociate it.

You * cannot disassociate the CIDR block with which you originally created the VPC * (the primary CIDR block).

See Also:

AWS * API Reference

*/ virtual Model::DisassociateVpcCidrBlockOutcome DisassociateVpcCidrBlock(const Model::DisassociateVpcCidrBlockRequest& request) const; /** * A Callable wrapper for DisassociateVpcCidrBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateVpcCidrBlockOutcomeCallable DisassociateVpcCidrBlockCallable(const DisassociateVpcCidrBlockRequestT& request) const { return SubmitCallable(&EC2Client::DisassociateVpcCidrBlock, request); } /** * An Async wrapper for DisassociateVpcCidrBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateVpcCidrBlockAsync(const DisassociateVpcCidrBlockRequestT& request, const DisassociateVpcCidrBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::DisassociateVpcCidrBlock, request, handler, context); } /** *

Enables Elastic IP address transfer. For more information, see Transfer * Elastic IP addresses in the Amazon Virtual Private Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::EnableAddressTransferOutcome EnableAddressTransfer(const Model::EnableAddressTransferRequest& request) const; /** * A Callable wrapper for EnableAddressTransfer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableAddressTransferOutcomeCallable EnableAddressTransferCallable(const EnableAddressTransferRequestT& request) const { return SubmitCallable(&EC2Client::EnableAddressTransfer, request); } /** * An Async wrapper for EnableAddressTransfer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableAddressTransferAsync(const EnableAddressTransferRequestT& request, const EnableAddressTransferResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableAddressTransfer, request, handler, context); } /** *

Enables Infrastructure Performance subscriptions.

See Also:

* AWS * API Reference

*/ virtual Model::EnableAwsNetworkPerformanceMetricSubscriptionOutcome EnableAwsNetworkPerformanceMetricSubscription(const Model::EnableAwsNetworkPerformanceMetricSubscriptionRequest& request) const; /** * A Callable wrapper for EnableAwsNetworkPerformanceMetricSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableAwsNetworkPerformanceMetricSubscriptionOutcomeCallable EnableAwsNetworkPerformanceMetricSubscriptionCallable(const EnableAwsNetworkPerformanceMetricSubscriptionRequestT& request) const { return SubmitCallable(&EC2Client::EnableAwsNetworkPerformanceMetricSubscription, request); } /** * An Async wrapper for EnableAwsNetworkPerformanceMetricSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableAwsNetworkPerformanceMetricSubscriptionAsync(const EnableAwsNetworkPerformanceMetricSubscriptionRequestT& request, const EnableAwsNetworkPerformanceMetricSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableAwsNetworkPerformanceMetricSubscription, request, handler, context); } /** *

Enables EBS encryption by default for your account in the current Region.

*

After you enable encryption by default, the EBS volumes that you create are * always encrypted, either using the default KMS key or the KMS key that you * specified when you created each volume. For more information, see Amazon * EBS encryption in the Amazon Elastic Compute Cloud User Guide.

*

You can specify the default KMS key for encryption by default using * ModifyEbsDefaultKmsKeyId or ResetEbsDefaultKmsKeyId.

*

Enabling encryption by default has no effect on the encryption status of your * existing volumes.

After you enable encryption by default, you can no * longer launch instances using instance types that do not support encryption. For * more information, see Supported * instance types.

See Also:

AWS * API Reference

*/ virtual Model::EnableEbsEncryptionByDefaultOutcome EnableEbsEncryptionByDefault(const Model::EnableEbsEncryptionByDefaultRequest& request) const; /** * A Callable wrapper for EnableEbsEncryptionByDefault that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableEbsEncryptionByDefaultOutcomeCallable EnableEbsEncryptionByDefaultCallable(const EnableEbsEncryptionByDefaultRequestT& request) const { return SubmitCallable(&EC2Client::EnableEbsEncryptionByDefault, request); } /** * An Async wrapper for EnableEbsEncryptionByDefault that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableEbsEncryptionByDefaultAsync(const EnableEbsEncryptionByDefaultRequestT& request, const EnableEbsEncryptionByDefaultResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableEbsEncryptionByDefault, request, handler, context); } /** *

When you enable faster launching for a Windows AMI, images are * pre-provisioned, using snapshots to launch instances up to 65% faster. To create * the optimized Windows image, Amazon EC2 launches an instance and runs through * Sysprep steps, rebooting as required. Then it creates a set of reserved * snapshots that are used for subsequent launches. The reserved snapshots are * automatically replenished as they are used, depending on your settings for * launch frequency.

To change these settings, you must own the * AMI.

See Also:

AWS * API Reference

*/ virtual Model::EnableFastLaunchOutcome EnableFastLaunch(const Model::EnableFastLaunchRequest& request) const; /** * A Callable wrapper for EnableFastLaunch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableFastLaunchOutcomeCallable EnableFastLaunchCallable(const EnableFastLaunchRequestT& request) const { return SubmitCallable(&EC2Client::EnableFastLaunch, request); } /** * An Async wrapper for EnableFastLaunch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableFastLaunchAsync(const EnableFastLaunchRequestT& request, const EnableFastLaunchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableFastLaunch, request, handler, context); } /** *

Enables fast snapshot restores for the specified snapshots in the specified * Availability Zones.

You get the full benefit of fast snapshot restores * after they enter the enabled state. To get the current state of * fast snapshot restores, use DescribeFastSnapshotRestores. To disable fast * snapshot restores, use DisableFastSnapshotRestores.

For more * information, see Amazon * EBS fast snapshot restore in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::EnableFastSnapshotRestoresOutcome EnableFastSnapshotRestores(const Model::EnableFastSnapshotRestoresRequest& request) const; /** * A Callable wrapper for EnableFastSnapshotRestores that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableFastSnapshotRestoresOutcomeCallable EnableFastSnapshotRestoresCallable(const EnableFastSnapshotRestoresRequestT& request) const { return SubmitCallable(&EC2Client::EnableFastSnapshotRestores, request); } /** * An Async wrapper for EnableFastSnapshotRestores that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableFastSnapshotRestoresAsync(const EnableFastSnapshotRestoresRequestT& request, const EnableFastSnapshotRestoresResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableFastSnapshotRestores, request, handler, context); } /** *

Enables deprecation of the specified AMI at the specified date and time.

*

For more information, see Deprecate * an AMI in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::EnableImageDeprecationOutcome EnableImageDeprecation(const Model::EnableImageDeprecationRequest& request) const; /** * A Callable wrapper for EnableImageDeprecation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableImageDeprecationOutcomeCallable EnableImageDeprecationCallable(const EnableImageDeprecationRequestT& request) const { return SubmitCallable(&EC2Client::EnableImageDeprecation, request); } /** * An Async wrapper for EnableImageDeprecation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableImageDeprecationAsync(const EnableImageDeprecationRequestT& request, const EnableImageDeprecationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableImageDeprecation, request, handler, context); } /** *

Enable an Organizations member account as the IPAM admin account. You cannot * select the Organizations management account as the IPAM admin account. For more * information, see Enable * integration with Organizations in the Amazon VPC IPAM User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::EnableIpamOrganizationAdminAccountOutcome EnableIpamOrganizationAdminAccount(const Model::EnableIpamOrganizationAdminAccountRequest& request) const; /** * A Callable wrapper for EnableIpamOrganizationAdminAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableIpamOrganizationAdminAccountOutcomeCallable EnableIpamOrganizationAdminAccountCallable(const EnableIpamOrganizationAdminAccountRequestT& request) const { return SubmitCallable(&EC2Client::EnableIpamOrganizationAdminAccount, request); } /** * An Async wrapper for EnableIpamOrganizationAdminAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableIpamOrganizationAdminAccountAsync(const EnableIpamOrganizationAdminAccountRequestT& request, const EnableIpamOrganizationAdminAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableIpamOrganizationAdminAccount, request, handler, context); } /** *

Establishes a trust relationship between Reachability Analyzer and * Organizations. This operation must be performed by the management account for * the organization.

After you establish a trust relationship, a user in the * management account or a delegated administrator account can run a cross-account * analysis using resources from the member accounts.

See Also:

AWS * API Reference

*/ virtual Model::EnableReachabilityAnalyzerOrganizationSharingOutcome EnableReachabilityAnalyzerOrganizationSharing(const Model::EnableReachabilityAnalyzerOrganizationSharingRequest& request) const; /** * A Callable wrapper for EnableReachabilityAnalyzerOrganizationSharing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableReachabilityAnalyzerOrganizationSharingOutcomeCallable EnableReachabilityAnalyzerOrganizationSharingCallable(const EnableReachabilityAnalyzerOrganizationSharingRequestT& request) const { return SubmitCallable(&EC2Client::EnableReachabilityAnalyzerOrganizationSharing, request); } /** * An Async wrapper for EnableReachabilityAnalyzerOrganizationSharing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableReachabilityAnalyzerOrganizationSharingAsync(const EnableReachabilityAnalyzerOrganizationSharingRequestT& request, const EnableReachabilityAnalyzerOrganizationSharingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableReachabilityAnalyzerOrganizationSharing, request, handler, context); } /** *

Enables access to the EC2 serial console of all instances for your account. * By default, access to the EC2 serial console is disabled for your account. For * more information, see Manage * account access to the EC2 serial console in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::EnableSerialConsoleAccessOutcome EnableSerialConsoleAccess(const Model::EnableSerialConsoleAccessRequest& request) const; /** * A Callable wrapper for EnableSerialConsoleAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableSerialConsoleAccessOutcomeCallable EnableSerialConsoleAccessCallable(const EnableSerialConsoleAccessRequestT& request) const { return SubmitCallable(&EC2Client::EnableSerialConsoleAccess, request); } /** * An Async wrapper for EnableSerialConsoleAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableSerialConsoleAccessAsync(const EnableSerialConsoleAccessRequestT& request, const EnableSerialConsoleAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableSerialConsoleAccess, request, handler, context); } /** *

Enables the specified attachment to propagate routes to the specified * propagation route table.

See Also:

AWS * API Reference

*/ virtual Model::EnableTransitGatewayRouteTablePropagationOutcome EnableTransitGatewayRouteTablePropagation(const Model::EnableTransitGatewayRouteTablePropagationRequest& request) const; /** * A Callable wrapper for EnableTransitGatewayRouteTablePropagation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableTransitGatewayRouteTablePropagationOutcomeCallable EnableTransitGatewayRouteTablePropagationCallable(const EnableTransitGatewayRouteTablePropagationRequestT& request) const { return SubmitCallable(&EC2Client::EnableTransitGatewayRouteTablePropagation, request); } /** * An Async wrapper for EnableTransitGatewayRouteTablePropagation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableTransitGatewayRouteTablePropagationAsync(const EnableTransitGatewayRouteTablePropagationRequestT& request, const EnableTransitGatewayRouteTablePropagationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableTransitGatewayRouteTablePropagation, request, handler, context); } /** *

Enables a virtual private gateway (VGW) to propagate routes to the specified * route table of a VPC.

See Also:

AWS * API Reference

*/ virtual Model::EnableVgwRoutePropagationOutcome EnableVgwRoutePropagation(const Model::EnableVgwRoutePropagationRequest& request) const; /** * A Callable wrapper for EnableVgwRoutePropagation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableVgwRoutePropagationOutcomeCallable EnableVgwRoutePropagationCallable(const EnableVgwRoutePropagationRequestT& request) const { return SubmitCallable(&EC2Client::EnableVgwRoutePropagation, request); } /** * An Async wrapper for EnableVgwRoutePropagation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableVgwRoutePropagationAsync(const EnableVgwRoutePropagationRequestT& request, const EnableVgwRoutePropagationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableVgwRoutePropagation, request, handler, context); } /** *

Enables I/O operations for a volume that had I/O operations disabled because * the data on the volume was potentially inconsistent.

See Also:

* AWS * API Reference

*/ virtual Model::EnableVolumeIOOutcome EnableVolumeIO(const Model::EnableVolumeIORequest& request) const; /** * A Callable wrapper for EnableVolumeIO that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableVolumeIOOutcomeCallable EnableVolumeIOCallable(const EnableVolumeIORequestT& request) const { return SubmitCallable(&EC2Client::EnableVolumeIO, request); } /** * An Async wrapper for EnableVolumeIO that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableVolumeIOAsync(const EnableVolumeIORequestT& request, const EnableVolumeIOResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableVolumeIO, request, handler, context); } /** *

This action is deprecated.

Enables a VPC for * ClassicLink. You can then link EC2-Classic instances to your ClassicLink-enabled * VPC to allow communication over private IP addresses. You cannot enable your VPC * for ClassicLink if any of your VPC route tables have existing routes for address * ranges within the 10.0.0.0/8 IP address range, excluding local * routes for VPCs in the 10.0.0.0/16 and 10.1.0.0/16 IP * address ranges.

See Also:

AWS * API Reference

*/ virtual Model::EnableVpcClassicLinkOutcome EnableVpcClassicLink(const Model::EnableVpcClassicLinkRequest& request) const; /** * A Callable wrapper for EnableVpcClassicLink that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableVpcClassicLinkOutcomeCallable EnableVpcClassicLinkCallable(const EnableVpcClassicLinkRequestT& request) const { return SubmitCallable(&EC2Client::EnableVpcClassicLink, request); } /** * An Async wrapper for EnableVpcClassicLink that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableVpcClassicLinkAsync(const EnableVpcClassicLinkRequestT& request, const EnableVpcClassicLinkResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableVpcClassicLink, request, handler, context); } /** *

This action is deprecated.

Enables a VPC to support DNS * hostname resolution for ClassicLink. If enabled, the DNS hostname of a linked * EC2-Classic instance resolves to its private IP address when addressed from an * instance in the VPC to which it's linked. Similarly, the DNS hostname of an * instance in a VPC resolves to its private IP address when addressed from a * linked EC2-Classic instance.

You must specify a VPC ID in the * request.

See Also:

AWS * API Reference

*/ virtual Model::EnableVpcClassicLinkDnsSupportOutcome EnableVpcClassicLinkDnsSupport(const Model::EnableVpcClassicLinkDnsSupportRequest& request) const; /** * A Callable wrapper for EnableVpcClassicLinkDnsSupport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableVpcClassicLinkDnsSupportOutcomeCallable EnableVpcClassicLinkDnsSupportCallable(const EnableVpcClassicLinkDnsSupportRequestT& request) const { return SubmitCallable(&EC2Client::EnableVpcClassicLinkDnsSupport, request); } /** * An Async wrapper for EnableVpcClassicLinkDnsSupport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableVpcClassicLinkDnsSupportAsync(const EnableVpcClassicLinkDnsSupportRequestT& request, const EnableVpcClassicLinkDnsSupportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::EnableVpcClassicLinkDnsSupport, request, handler, context); } /** *

Downloads the client certificate revocation list for the specified Client VPN * endpoint.

See Also:

AWS * API Reference

*/ virtual Model::ExportClientVpnClientCertificateRevocationListOutcome ExportClientVpnClientCertificateRevocationList(const Model::ExportClientVpnClientCertificateRevocationListRequest& request) const; /** * A Callable wrapper for ExportClientVpnClientCertificateRevocationList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExportClientVpnClientCertificateRevocationListOutcomeCallable ExportClientVpnClientCertificateRevocationListCallable(const ExportClientVpnClientCertificateRevocationListRequestT& request) const { return SubmitCallable(&EC2Client::ExportClientVpnClientCertificateRevocationList, request); } /** * An Async wrapper for ExportClientVpnClientCertificateRevocationList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExportClientVpnClientCertificateRevocationListAsync(const ExportClientVpnClientCertificateRevocationListRequestT& request, const ExportClientVpnClientCertificateRevocationListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ExportClientVpnClientCertificateRevocationList, request, handler, context); } /** *

Downloads the contents of the Client VPN endpoint configuration file for the * specified Client VPN endpoint. The Client VPN endpoint configuration file * includes the Client VPN endpoint and certificate information clients need to * establish a connection with the Client VPN endpoint.

See Also:

* AWS * API Reference

*/ virtual Model::ExportClientVpnClientConfigurationOutcome ExportClientVpnClientConfiguration(const Model::ExportClientVpnClientConfigurationRequest& request) const; /** * A Callable wrapper for ExportClientVpnClientConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExportClientVpnClientConfigurationOutcomeCallable ExportClientVpnClientConfigurationCallable(const ExportClientVpnClientConfigurationRequestT& request) const { return SubmitCallable(&EC2Client::ExportClientVpnClientConfiguration, request); } /** * An Async wrapper for ExportClientVpnClientConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExportClientVpnClientConfigurationAsync(const ExportClientVpnClientConfigurationRequestT& request, const ExportClientVpnClientConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ExportClientVpnClientConfiguration, request, handler, context); } /** *

Exports an Amazon Machine Image (AMI) to a VM file. For more information, see * Exporting * a VM directly from an Amazon Machine Image (AMI) in the VM Import/Export * User Guide.

See Also:

AWS API * Reference

*/ virtual Model::ExportImageOutcome ExportImage(const Model::ExportImageRequest& request) const; /** * A Callable wrapper for ExportImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExportImageOutcomeCallable ExportImageCallable(const ExportImageRequestT& request) const { return SubmitCallable(&EC2Client::ExportImage, request); } /** * An Async wrapper for ExportImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExportImageAsync(const ExportImageRequestT& request, const ExportImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ExportImage, request, handler, context); } /** *

Exports routes from the specified transit gateway route table to the * specified S3 bucket. By default, all routes are exported. Alternatively, you can * filter by CIDR range.

The routes are saved to the specified bucket in a * JSON file. For more information, see Export * Route Tables to Amazon S3 in Transit Gateways.

See * Also:

AWS * API Reference

*/ virtual Model::ExportTransitGatewayRoutesOutcome ExportTransitGatewayRoutes(const Model::ExportTransitGatewayRoutesRequest& request) const; /** * A Callable wrapper for ExportTransitGatewayRoutes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExportTransitGatewayRoutesOutcomeCallable ExportTransitGatewayRoutesCallable(const ExportTransitGatewayRoutesRequestT& request) const { return SubmitCallable(&EC2Client::ExportTransitGatewayRoutes, request); } /** * An Async wrapper for ExportTransitGatewayRoutes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExportTransitGatewayRoutesAsync(const ExportTransitGatewayRoutesRequestT& request, const ExportTransitGatewayRoutesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ExportTransitGatewayRoutes, request, handler, context); } /** *

Returns the IAM roles that are associated with the specified ACM (ACM) * certificate. It also returns the name of the Amazon S3 bucket and the Amazon S3 * object key where the certificate, certificate chain, and encrypted private key * bundle are stored, and the ARN of the KMS key that's used to encrypt the private * key.

See Also:

AWS * API Reference

*/ virtual Model::GetAssociatedEnclaveCertificateIamRolesOutcome GetAssociatedEnclaveCertificateIamRoles(const Model::GetAssociatedEnclaveCertificateIamRolesRequest& request) const; /** * A Callable wrapper for GetAssociatedEnclaveCertificateIamRoles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAssociatedEnclaveCertificateIamRolesOutcomeCallable GetAssociatedEnclaveCertificateIamRolesCallable(const GetAssociatedEnclaveCertificateIamRolesRequestT& request) const { return SubmitCallable(&EC2Client::GetAssociatedEnclaveCertificateIamRoles, request); } /** * An Async wrapper for GetAssociatedEnclaveCertificateIamRoles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAssociatedEnclaveCertificateIamRolesAsync(const GetAssociatedEnclaveCertificateIamRolesRequestT& request, const GetAssociatedEnclaveCertificateIamRolesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetAssociatedEnclaveCertificateIamRoles, request, handler, context); } /** *

Gets information about the IPv6 CIDR block associations for a specified IPv6 * address pool.

See Also:

AWS * API Reference

*/ virtual Model::GetAssociatedIpv6PoolCidrsOutcome GetAssociatedIpv6PoolCidrs(const Model::GetAssociatedIpv6PoolCidrsRequest& request) const; /** * A Callable wrapper for GetAssociatedIpv6PoolCidrs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAssociatedIpv6PoolCidrsOutcomeCallable GetAssociatedIpv6PoolCidrsCallable(const GetAssociatedIpv6PoolCidrsRequestT& request) const { return SubmitCallable(&EC2Client::GetAssociatedIpv6PoolCidrs, request); } /** * An Async wrapper for GetAssociatedIpv6PoolCidrs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAssociatedIpv6PoolCidrsAsync(const GetAssociatedIpv6PoolCidrsRequestT& request, const GetAssociatedIpv6PoolCidrsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetAssociatedIpv6PoolCidrs, request, handler, context); } /** *

Gets network performance data.

See Also:

AWS * API Reference

*/ virtual Model::GetAwsNetworkPerformanceDataOutcome GetAwsNetworkPerformanceData(const Model::GetAwsNetworkPerformanceDataRequest& request) const; /** * A Callable wrapper for GetAwsNetworkPerformanceData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAwsNetworkPerformanceDataOutcomeCallable GetAwsNetworkPerformanceDataCallable(const GetAwsNetworkPerformanceDataRequestT& request) const { return SubmitCallable(&EC2Client::GetAwsNetworkPerformanceData, request); } /** * An Async wrapper for GetAwsNetworkPerformanceData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAwsNetworkPerformanceDataAsync(const GetAwsNetworkPerformanceDataRequestT& request, const GetAwsNetworkPerformanceDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetAwsNetworkPerformanceData, request, handler, context); } /** *

Gets usage information about a Capacity Reservation. If the Capacity * Reservation is shared, it shows usage information for the Capacity Reservation * owner and each Amazon Web Services account that is currently using the shared * capacity. If the Capacity Reservation is not shared, it shows only the Capacity * Reservation owner's usage.

See Also:

AWS * API Reference

*/ virtual Model::GetCapacityReservationUsageOutcome GetCapacityReservationUsage(const Model::GetCapacityReservationUsageRequest& request) const; /** * A Callable wrapper for GetCapacityReservationUsage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCapacityReservationUsageOutcomeCallable GetCapacityReservationUsageCallable(const GetCapacityReservationUsageRequestT& request) const { return SubmitCallable(&EC2Client::GetCapacityReservationUsage, request); } /** * An Async wrapper for GetCapacityReservationUsage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCapacityReservationUsageAsync(const GetCapacityReservationUsageRequestT& request, const GetCapacityReservationUsageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetCapacityReservationUsage, request, handler, context); } /** *

Describes the allocations from the specified customer-owned address * pool.

See Also:

AWS * API Reference

*/ virtual Model::GetCoipPoolUsageOutcome GetCoipPoolUsage(const Model::GetCoipPoolUsageRequest& request) const; /** * A Callable wrapper for GetCoipPoolUsage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCoipPoolUsageOutcomeCallable GetCoipPoolUsageCallable(const GetCoipPoolUsageRequestT& request) const { return SubmitCallable(&EC2Client::GetCoipPoolUsage, request); } /** * An Async wrapper for GetCoipPoolUsage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCoipPoolUsageAsync(const GetCoipPoolUsageRequestT& request, const GetCoipPoolUsageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetCoipPoolUsage, request, handler, context); } /** *

Gets the console output for the specified instance. For Linux instances, the * instance console output displays the exact console output that would normally be * displayed on a physical monitor attached to a computer. For Windows instances, * the instance console output includes the last three system event log errors.

*

By default, the console output returns buffered information that was posted * shortly after an instance transition state (start, stop, reboot, or terminate). * This information is available for at least one hour after the most recent post. * Only the most recent 64 KB of console output is available.

You can * optionally retrieve the latest serial console output at any time during the * instance lifecycle. This option is supported on instance types that use the * Nitro hypervisor.

For more information, see Instance * console output in the Amazon EC2 User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::GetConsoleOutputOutcome GetConsoleOutput(const Model::GetConsoleOutputRequest& request) const; /** * A Callable wrapper for GetConsoleOutput that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetConsoleOutputOutcomeCallable GetConsoleOutputCallable(const GetConsoleOutputRequestT& request) const { return SubmitCallable(&EC2Client::GetConsoleOutput, request); } /** * An Async wrapper for GetConsoleOutput that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetConsoleOutputAsync(const GetConsoleOutputRequestT& request, const GetConsoleOutputResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetConsoleOutput, request, handler, context); } /** *

Retrieve a JPG-format screenshot of a running instance to help with * troubleshooting.

The returned content is Base64-encoded.

See * Also:

AWS * API Reference

*/ virtual Model::GetConsoleScreenshotOutcome GetConsoleScreenshot(const Model::GetConsoleScreenshotRequest& request) const; /** * A Callable wrapper for GetConsoleScreenshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetConsoleScreenshotOutcomeCallable GetConsoleScreenshotCallable(const GetConsoleScreenshotRequestT& request) const { return SubmitCallable(&EC2Client::GetConsoleScreenshot, request); } /** * An Async wrapper for GetConsoleScreenshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetConsoleScreenshotAsync(const GetConsoleScreenshotRequestT& request, const GetConsoleScreenshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetConsoleScreenshot, request, handler, context); } /** *

Describes the default credit option for CPU usage of a burstable performance * instance family.

For more information, see Burstable * performance instances in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::GetDefaultCreditSpecificationOutcome GetDefaultCreditSpecification(const Model::GetDefaultCreditSpecificationRequest& request) const; /** * A Callable wrapper for GetDefaultCreditSpecification that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDefaultCreditSpecificationOutcomeCallable GetDefaultCreditSpecificationCallable(const GetDefaultCreditSpecificationRequestT& request) const { return SubmitCallable(&EC2Client::GetDefaultCreditSpecification, request); } /** * An Async wrapper for GetDefaultCreditSpecification that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDefaultCreditSpecificationAsync(const GetDefaultCreditSpecificationRequestT& request, const GetDefaultCreditSpecificationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetDefaultCreditSpecification, request, handler, context); } /** *

Describes the default KMS key for EBS encryption by default for your account * in this Region. You can change the default KMS key for encryption by default * using ModifyEbsDefaultKmsKeyId or ResetEbsDefaultKmsKeyId.

*

For more information, see Amazon * EBS encryption in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetEbsDefaultKmsKeyIdOutcome GetEbsDefaultKmsKeyId(const Model::GetEbsDefaultKmsKeyIdRequest& request) const; /** * A Callable wrapper for GetEbsDefaultKmsKeyId that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEbsDefaultKmsKeyIdOutcomeCallable GetEbsDefaultKmsKeyIdCallable(const GetEbsDefaultKmsKeyIdRequestT& request) const { return SubmitCallable(&EC2Client::GetEbsDefaultKmsKeyId, request); } /** * An Async wrapper for GetEbsDefaultKmsKeyId that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEbsDefaultKmsKeyIdAsync(const GetEbsDefaultKmsKeyIdRequestT& request, const GetEbsDefaultKmsKeyIdResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetEbsDefaultKmsKeyId, request, handler, context); } /** *

Describes whether EBS encryption by default is enabled for your account in * the current Region.

For more information, see Amazon * EBS encryption in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetEbsEncryptionByDefaultOutcome GetEbsEncryptionByDefault(const Model::GetEbsEncryptionByDefaultRequest& request) const; /** * A Callable wrapper for GetEbsEncryptionByDefault that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEbsEncryptionByDefaultOutcomeCallable GetEbsEncryptionByDefaultCallable(const GetEbsEncryptionByDefaultRequestT& request) const { return SubmitCallable(&EC2Client::GetEbsEncryptionByDefault, request); } /** * An Async wrapper for GetEbsEncryptionByDefault that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEbsEncryptionByDefaultAsync(const GetEbsEncryptionByDefaultRequestT& request, const GetEbsEncryptionByDefaultResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetEbsEncryptionByDefault, request, handler, context); } /** *

Generates a CloudFormation template that streamlines and automates the * integration of VPC flow logs with Amazon Athena. This make it easier for you to * query and gain insights from VPC flow logs data. Based on the information that * you provide, we configure resources in the template to do the following:

*

  • Create a table in Athena that maps fields to a custom log * format

  • Create a Lambda function that updates the table with * new partitions on a daily, weekly, or monthly basis

  • Create a * table partitioned between two timestamps in the past

  • Create a * set of named queries in Athena that you can use to get started quickly

    • *

GetFlowLogsIntegrationTemplate does not support * integration between Amazon Web Services Transit Gateway Flow Logs and Amazon * Athena.

See Also:

AWS * API Reference

*/ virtual Model::GetFlowLogsIntegrationTemplateOutcome GetFlowLogsIntegrationTemplate(const Model::GetFlowLogsIntegrationTemplateRequest& request) const; /** * A Callable wrapper for GetFlowLogsIntegrationTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFlowLogsIntegrationTemplateOutcomeCallable GetFlowLogsIntegrationTemplateCallable(const GetFlowLogsIntegrationTemplateRequestT& request) const { return SubmitCallable(&EC2Client::GetFlowLogsIntegrationTemplate, request); } /** * An Async wrapper for GetFlowLogsIntegrationTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFlowLogsIntegrationTemplateAsync(const GetFlowLogsIntegrationTemplateRequestT& request, const GetFlowLogsIntegrationTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetFlowLogsIntegrationTemplate, request, handler, context); } /** *

Lists the resource groups to which a Capacity Reservation has been * added.

See Also:

AWS * API Reference

*/ virtual Model::GetGroupsForCapacityReservationOutcome GetGroupsForCapacityReservation(const Model::GetGroupsForCapacityReservationRequest& request) const; /** * A Callable wrapper for GetGroupsForCapacityReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetGroupsForCapacityReservationOutcomeCallable GetGroupsForCapacityReservationCallable(const GetGroupsForCapacityReservationRequestT& request) const { return SubmitCallable(&EC2Client::GetGroupsForCapacityReservation, request); } /** * An Async wrapper for GetGroupsForCapacityReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetGroupsForCapacityReservationAsync(const GetGroupsForCapacityReservationRequestT& request, const GetGroupsForCapacityReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetGroupsForCapacityReservation, request, handler, context); } /** *

Preview a reservation purchase with configurations that match those of your * Dedicated Host. You must have active Dedicated Hosts in your account before you * purchase a reservation.

This is a preview of the * PurchaseHostReservation action and does not result in the offering being * purchased.

See Also:

AWS * API Reference

*/ virtual Model::GetHostReservationPurchasePreviewOutcome GetHostReservationPurchasePreview(const Model::GetHostReservationPurchasePreviewRequest& request) const; /** * A Callable wrapper for GetHostReservationPurchasePreview that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetHostReservationPurchasePreviewOutcomeCallable GetHostReservationPurchasePreviewCallable(const GetHostReservationPurchasePreviewRequestT& request) const { return SubmitCallable(&EC2Client::GetHostReservationPurchasePreview, request); } /** * An Async wrapper for GetHostReservationPurchasePreview that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetHostReservationPurchasePreviewAsync(const GetHostReservationPurchasePreviewRequestT& request, const GetHostReservationPurchasePreviewResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetHostReservationPurchasePreview, request, handler, context); } /** *

Returns a list of instance types with the specified instance attributes. You * can use the response to preview the instance types without launching instances. * Note that the response does not consider capacity.

When you specify * multiple parameters, you get instance types that satisfy all of the specified * parameters. If you specify multiple values for a parameter, you get instance * types that satisfy any of the specified values.

For more information, see * Preview * instance types with specified attributes, Attribute-based * instance type selection for EC2 Fleet, Attribute-based * instance type selection for Spot Fleet, and Spot * placement score in the Amazon EC2 User Guide, and Creating * an Auto Scaling group using attribute-based instance type selection in the * Amazon EC2 Auto Scaling User Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetInstanceTypesFromInstanceRequirementsOutcome GetInstanceTypesFromInstanceRequirements(const Model::GetInstanceTypesFromInstanceRequirementsRequest& request) const; /** * A Callable wrapper for GetInstanceTypesFromInstanceRequirements that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstanceTypesFromInstanceRequirementsOutcomeCallable GetInstanceTypesFromInstanceRequirementsCallable(const GetInstanceTypesFromInstanceRequirementsRequestT& request) const { return SubmitCallable(&EC2Client::GetInstanceTypesFromInstanceRequirements, request); } /** * An Async wrapper for GetInstanceTypesFromInstanceRequirements that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstanceTypesFromInstanceRequirementsAsync(const GetInstanceTypesFromInstanceRequirementsRequestT& request, const GetInstanceTypesFromInstanceRequirementsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetInstanceTypesFromInstanceRequirements, request, handler, context); } /** *

A binary representation of the UEFI variable store. Only non-volatile * variables are stored. This is a base64 encoded and zlib compressed binary value * that must be properly encoded.

When you use register-image * to create an AMI, you can create an exact copy of your variable store by passing * the UEFI data in the UefiData parameter. You can modify the UEFI * data by using the python-uefivars tool on * GitHub. You can use the tool to convert the UEFI data into a human-readable * format (JSON), which you can inspect and modify, and then convert back into the * binary format to use with register-image.

For more information, see UEFI * Secure Boot in the Amazon EC2 User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::GetInstanceUefiDataOutcome GetInstanceUefiData(const Model::GetInstanceUefiDataRequest& request) const; /** * A Callable wrapper for GetInstanceUefiData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInstanceUefiDataOutcomeCallable GetInstanceUefiDataCallable(const GetInstanceUefiDataRequestT& request) const { return SubmitCallable(&EC2Client::GetInstanceUefiData, request); } /** * An Async wrapper for GetInstanceUefiData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInstanceUefiDataAsync(const GetInstanceUefiDataRequestT& request, const GetInstanceUefiDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetInstanceUefiData, request, handler, context); } /** *

Retrieve historical information about a CIDR within an IPAM scope. For more * information, see View * the history of IP addresses in the Amazon VPC IPAM User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetIpamAddressHistoryOutcome GetIpamAddressHistory(const Model::GetIpamAddressHistoryRequest& request) const; /** * A Callable wrapper for GetIpamAddressHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIpamAddressHistoryOutcomeCallable GetIpamAddressHistoryCallable(const GetIpamAddressHistoryRequestT& request) const { return SubmitCallable(&EC2Client::GetIpamAddressHistory, request); } /** * An Async wrapper for GetIpamAddressHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIpamAddressHistoryAsync(const GetIpamAddressHistoryRequestT& request, const GetIpamAddressHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetIpamAddressHistory, request, handler, context); } /** *

Gets IPAM discovered accounts. A discovered account is an Amazon Web Services * account that is monitored under a resource discovery. If you have integrated * IPAM with Amazon Web Services Organizations, all accounts in the organization * are discovered accounts. Only the IPAM account can get all discovered accounts * in the organization.

See Also:

AWS * API Reference

*/ virtual Model::GetIpamDiscoveredAccountsOutcome GetIpamDiscoveredAccounts(const Model::GetIpamDiscoveredAccountsRequest& request) const; /** * A Callable wrapper for GetIpamDiscoveredAccounts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIpamDiscoveredAccountsOutcomeCallable GetIpamDiscoveredAccountsCallable(const GetIpamDiscoveredAccountsRequestT& request) const { return SubmitCallable(&EC2Client::GetIpamDiscoveredAccounts, request); } /** * An Async wrapper for GetIpamDiscoveredAccounts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIpamDiscoveredAccountsAsync(const GetIpamDiscoveredAccountsRequestT& request, const GetIpamDiscoveredAccountsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetIpamDiscoveredAccounts, request, handler, context); } /** *

Returns the resource CIDRs that are monitored as part of a resource * discovery. A discovered resource is a resource CIDR monitored under a resource * discovery. The following resources can be discovered: VPCs, Public IPv4 pools, * VPC subnets, and Elastic IP addresses.

See Also:

AWS * API Reference

*/ virtual Model::GetIpamDiscoveredResourceCidrsOutcome GetIpamDiscoveredResourceCidrs(const Model::GetIpamDiscoveredResourceCidrsRequest& request) const; /** * A Callable wrapper for GetIpamDiscoveredResourceCidrs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIpamDiscoveredResourceCidrsOutcomeCallable GetIpamDiscoveredResourceCidrsCallable(const GetIpamDiscoveredResourceCidrsRequestT& request) const { return SubmitCallable(&EC2Client::GetIpamDiscoveredResourceCidrs, request); } /** * An Async wrapper for GetIpamDiscoveredResourceCidrs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIpamDiscoveredResourceCidrsAsync(const GetIpamDiscoveredResourceCidrsRequestT& request, const GetIpamDiscoveredResourceCidrsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetIpamDiscoveredResourceCidrs, request, handler, context); } /** *

Get a list of all the CIDR allocations in an IPAM pool. The Region you use * should be the IPAM pool locale. The locale is the Amazon Web Services Region * where this IPAM pool is available for allocations.

If you use this * action after AllocateIpamPoolCidr * or ReleaseIpamPoolAllocation, * note that all EC2 API actions follow an eventual * consistency model.

See Also:

AWS * API Reference

*/ virtual Model::GetIpamPoolAllocationsOutcome GetIpamPoolAllocations(const Model::GetIpamPoolAllocationsRequest& request) const; /** * A Callable wrapper for GetIpamPoolAllocations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIpamPoolAllocationsOutcomeCallable GetIpamPoolAllocationsCallable(const GetIpamPoolAllocationsRequestT& request) const { return SubmitCallable(&EC2Client::GetIpamPoolAllocations, request); } /** * An Async wrapper for GetIpamPoolAllocations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIpamPoolAllocationsAsync(const GetIpamPoolAllocationsRequestT& request, const GetIpamPoolAllocationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetIpamPoolAllocations, request, handler, context); } /** *

Get the CIDRs provisioned to an IPAM pool.

See Also:

AWS * API Reference

*/ virtual Model::GetIpamPoolCidrsOutcome GetIpamPoolCidrs(const Model::GetIpamPoolCidrsRequest& request) const; /** * A Callable wrapper for GetIpamPoolCidrs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIpamPoolCidrsOutcomeCallable GetIpamPoolCidrsCallable(const GetIpamPoolCidrsRequestT& request) const { return SubmitCallable(&EC2Client::GetIpamPoolCidrs, request); } /** * An Async wrapper for GetIpamPoolCidrs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIpamPoolCidrsAsync(const GetIpamPoolCidrsRequestT& request, const GetIpamPoolCidrsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetIpamPoolCidrs, request, handler, context); } /** *

Returns resource CIDRs managed by IPAM in a given scope. If an IPAM is * associated with more than one resource discovery, the resource CIDRs across all * of the resource discoveries is returned. A resource discovery is an IPAM * component that enables IPAM to manage and monitor resources that belong to the * owning account.

See Also:

AWS * API Reference

*/ virtual Model::GetIpamResourceCidrsOutcome GetIpamResourceCidrs(const Model::GetIpamResourceCidrsRequest& request) const; /** * A Callable wrapper for GetIpamResourceCidrs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIpamResourceCidrsOutcomeCallable GetIpamResourceCidrsCallable(const GetIpamResourceCidrsRequestT& request) const { return SubmitCallable(&EC2Client::GetIpamResourceCidrs, request); } /** * An Async wrapper for GetIpamResourceCidrs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIpamResourceCidrsAsync(const GetIpamResourceCidrsRequestT& request, const GetIpamResourceCidrsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetIpamResourceCidrs, request, handler, context); } /** *

Retrieves the configuration data of the specified instance. You can use this * data to create a launch template.

This action calls on other describe * actions to get instance information. Depending on your instance configuration, * you may need to allow the following actions in your IAM policy: * DescribeSpotInstanceRequests, * DescribeInstanceCreditSpecifications, DescribeVolumes, * DescribeInstanceAttribute, and DescribeElasticGpus. * Or, you can allow describe* depending on your instance * requirements.

See Also:

AWS * API Reference

*/ virtual Model::GetLaunchTemplateDataOutcome GetLaunchTemplateData(const Model::GetLaunchTemplateDataRequest& request) const; /** * A Callable wrapper for GetLaunchTemplateData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLaunchTemplateDataOutcomeCallable GetLaunchTemplateDataCallable(const GetLaunchTemplateDataRequestT& request) const { return SubmitCallable(&EC2Client::GetLaunchTemplateData, request); } /** * An Async wrapper for GetLaunchTemplateData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLaunchTemplateDataAsync(const GetLaunchTemplateDataRequestT& request, const GetLaunchTemplateDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetLaunchTemplateData, request, handler, context); } /** *

Gets information about the resources that are associated with the specified * managed prefix list.

See Also:

AWS * API Reference

*/ virtual Model::GetManagedPrefixListAssociationsOutcome GetManagedPrefixListAssociations(const Model::GetManagedPrefixListAssociationsRequest& request) const; /** * A Callable wrapper for GetManagedPrefixListAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetManagedPrefixListAssociationsOutcomeCallable GetManagedPrefixListAssociationsCallable(const GetManagedPrefixListAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::GetManagedPrefixListAssociations, request); } /** * An Async wrapper for GetManagedPrefixListAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetManagedPrefixListAssociationsAsync(const GetManagedPrefixListAssociationsRequestT& request, const GetManagedPrefixListAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetManagedPrefixListAssociations, request, handler, context); } /** *

Gets information about the entries for a specified managed prefix * list.

See Also:

AWS * API Reference

*/ virtual Model::GetManagedPrefixListEntriesOutcome GetManagedPrefixListEntries(const Model::GetManagedPrefixListEntriesRequest& request) const; /** * A Callable wrapper for GetManagedPrefixListEntries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetManagedPrefixListEntriesOutcomeCallable GetManagedPrefixListEntriesCallable(const GetManagedPrefixListEntriesRequestT& request) const { return SubmitCallable(&EC2Client::GetManagedPrefixListEntries, request); } /** * An Async wrapper for GetManagedPrefixListEntries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetManagedPrefixListEntriesAsync(const GetManagedPrefixListEntriesRequestT& request, const GetManagedPrefixListEntriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetManagedPrefixListEntries, request, handler, context); } /** *

Gets the findings for the specified Network Access Scope * analysis.

See Also:

AWS * API Reference

*/ virtual Model::GetNetworkInsightsAccessScopeAnalysisFindingsOutcome GetNetworkInsightsAccessScopeAnalysisFindings(const Model::GetNetworkInsightsAccessScopeAnalysisFindingsRequest& request) const; /** * A Callable wrapper for GetNetworkInsightsAccessScopeAnalysisFindings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetNetworkInsightsAccessScopeAnalysisFindingsOutcomeCallable GetNetworkInsightsAccessScopeAnalysisFindingsCallable(const GetNetworkInsightsAccessScopeAnalysisFindingsRequestT& request) const { return SubmitCallable(&EC2Client::GetNetworkInsightsAccessScopeAnalysisFindings, request); } /** * An Async wrapper for GetNetworkInsightsAccessScopeAnalysisFindings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetNetworkInsightsAccessScopeAnalysisFindingsAsync(const GetNetworkInsightsAccessScopeAnalysisFindingsRequestT& request, const GetNetworkInsightsAccessScopeAnalysisFindingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetNetworkInsightsAccessScopeAnalysisFindings, request, handler, context); } /** *

Gets the content for the specified Network Access Scope.

See * Also:

AWS * API Reference

*/ virtual Model::GetNetworkInsightsAccessScopeContentOutcome GetNetworkInsightsAccessScopeContent(const Model::GetNetworkInsightsAccessScopeContentRequest& request) const; /** * A Callable wrapper for GetNetworkInsightsAccessScopeContent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetNetworkInsightsAccessScopeContentOutcomeCallable GetNetworkInsightsAccessScopeContentCallable(const GetNetworkInsightsAccessScopeContentRequestT& request) const { return SubmitCallable(&EC2Client::GetNetworkInsightsAccessScopeContent, request); } /** * An Async wrapper for GetNetworkInsightsAccessScopeContent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetNetworkInsightsAccessScopeContentAsync(const GetNetworkInsightsAccessScopeContentRequestT& request, const GetNetworkInsightsAccessScopeContentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetNetworkInsightsAccessScopeContent, request, handler, context); } /** *

Retrieves the encrypted administrator password for a running Windows * instance.

The Windows password is generated at boot by the * EC2Config service or EC2Launch scripts (Windows Server * 2016 and later). This usually only happens the first time an instance is * launched. For more information, see EC2Config * and EC2Launch * in the Amazon EC2 User Guide.

For the EC2Config * service, the password is not generated for rebundled AMIs unless * Ec2SetPassword is enabled before bundling.

The password is * encrypted using the key pair that you specified when you launched the instance. * You must provide the corresponding key pair file.

When you launch an * instance, password generation and encryption may take a few minutes. If you try * to retrieve the password before it's available, the output returns an empty * string. We recommend that you wait up to 15 minutes after launching an instance * before trying to retrieve the generated password.

See Also:

AWS * API Reference

*/ virtual Model::GetPasswordDataOutcome GetPasswordData(const Model::GetPasswordDataRequest& request) const; /** * A Callable wrapper for GetPasswordData that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPasswordDataOutcomeCallable GetPasswordDataCallable(const GetPasswordDataRequestT& request) const { return SubmitCallable(&EC2Client::GetPasswordData, request); } /** * An Async wrapper for GetPasswordData that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPasswordDataAsync(const GetPasswordDataRequestT& request, const GetPasswordDataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetPasswordData, request, handler, context); } /** *

Returns a quote and exchange information for exchanging one or more specified * Convertible Reserved Instances for a new Convertible Reserved Instance. If the * exchange cannot be performed, the reason is returned in the response. Use * AcceptReservedInstancesExchangeQuote to perform the * exchange.

See Also:

AWS * API Reference

*/ virtual Model::GetReservedInstancesExchangeQuoteOutcome GetReservedInstancesExchangeQuote(const Model::GetReservedInstancesExchangeQuoteRequest& request) const; /** * A Callable wrapper for GetReservedInstancesExchangeQuote that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetReservedInstancesExchangeQuoteOutcomeCallable GetReservedInstancesExchangeQuoteCallable(const GetReservedInstancesExchangeQuoteRequestT& request) const { return SubmitCallable(&EC2Client::GetReservedInstancesExchangeQuote, request); } /** * An Async wrapper for GetReservedInstancesExchangeQuote that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetReservedInstancesExchangeQuoteAsync(const GetReservedInstancesExchangeQuoteRequestT& request, const GetReservedInstancesExchangeQuoteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetReservedInstancesExchangeQuote, request, handler, context); } /** *

Retrieves the access status of your account to the EC2 serial console of all * instances. By default, access to the EC2 serial console is disabled for your * account. For more information, see Manage * account access to the EC2 serial console in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetSerialConsoleAccessStatusOutcome GetSerialConsoleAccessStatus(const Model::GetSerialConsoleAccessStatusRequest& request) const; /** * A Callable wrapper for GetSerialConsoleAccessStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSerialConsoleAccessStatusOutcomeCallable GetSerialConsoleAccessStatusCallable(const GetSerialConsoleAccessStatusRequestT& request) const { return SubmitCallable(&EC2Client::GetSerialConsoleAccessStatus, request); } /** * An Async wrapper for GetSerialConsoleAccessStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSerialConsoleAccessStatusAsync(const GetSerialConsoleAccessStatusRequestT& request, const GetSerialConsoleAccessStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetSerialConsoleAccessStatus, request, handler, context); } /** *

Calculates the Spot placement score for a Region or Availability Zone based * on the specified target capacity and compute requirements.

You can * specify your compute requirements either by using * InstanceRequirementsWithMetadata and letting Amazon EC2 choose the * optimal instance types to fulfill your Spot request, or you can specify the * instance types by using InstanceTypes.

For more information, * see Spot * placement score in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetSpotPlacementScoresOutcome GetSpotPlacementScores(const Model::GetSpotPlacementScoresRequest& request) const; /** * A Callable wrapper for GetSpotPlacementScores that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSpotPlacementScoresOutcomeCallable GetSpotPlacementScoresCallable(const GetSpotPlacementScoresRequestT& request) const { return SubmitCallable(&EC2Client::GetSpotPlacementScores, request); } /** * An Async wrapper for GetSpotPlacementScores that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSpotPlacementScoresAsync(const GetSpotPlacementScoresRequestT& request, const GetSpotPlacementScoresResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetSpotPlacementScores, request, handler, context); } /** *

Gets information about the subnet CIDR reservations.

See Also:

* AWS * API Reference

*/ virtual Model::GetSubnetCidrReservationsOutcome GetSubnetCidrReservations(const Model::GetSubnetCidrReservationsRequest& request) const; /** * A Callable wrapper for GetSubnetCidrReservations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSubnetCidrReservationsOutcomeCallable GetSubnetCidrReservationsCallable(const GetSubnetCidrReservationsRequestT& request) const { return SubmitCallable(&EC2Client::GetSubnetCidrReservations, request); } /** * An Async wrapper for GetSubnetCidrReservations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSubnetCidrReservationsAsync(const GetSubnetCidrReservationsRequestT& request, const GetSubnetCidrReservationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetSubnetCidrReservations, request, handler, context); } /** *

Lists the route tables to which the specified resource attachment propagates * routes.

See Also:

AWS * API Reference

*/ virtual Model::GetTransitGatewayAttachmentPropagationsOutcome GetTransitGatewayAttachmentPropagations(const Model::GetTransitGatewayAttachmentPropagationsRequest& request) const; /** * A Callable wrapper for GetTransitGatewayAttachmentPropagations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTransitGatewayAttachmentPropagationsOutcomeCallable GetTransitGatewayAttachmentPropagationsCallable(const GetTransitGatewayAttachmentPropagationsRequestT& request) const { return SubmitCallable(&EC2Client::GetTransitGatewayAttachmentPropagations, request); } /** * An Async wrapper for GetTransitGatewayAttachmentPropagations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTransitGatewayAttachmentPropagationsAsync(const GetTransitGatewayAttachmentPropagationsRequestT& request, const GetTransitGatewayAttachmentPropagationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetTransitGatewayAttachmentPropagations, request, handler, context); } /** *

Gets information about the associations for the transit gateway multicast * domain.

See Also:

AWS * API Reference

*/ virtual Model::GetTransitGatewayMulticastDomainAssociationsOutcome GetTransitGatewayMulticastDomainAssociations(const Model::GetTransitGatewayMulticastDomainAssociationsRequest& request) const; /** * A Callable wrapper for GetTransitGatewayMulticastDomainAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTransitGatewayMulticastDomainAssociationsOutcomeCallable GetTransitGatewayMulticastDomainAssociationsCallable(const GetTransitGatewayMulticastDomainAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::GetTransitGatewayMulticastDomainAssociations, request); } /** * An Async wrapper for GetTransitGatewayMulticastDomainAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTransitGatewayMulticastDomainAssociationsAsync(const GetTransitGatewayMulticastDomainAssociationsRequestT& request, const GetTransitGatewayMulticastDomainAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetTransitGatewayMulticastDomainAssociations, request, handler, context); } /** *

Gets a list of the transit gateway policy table associations.

See * Also:

AWS * API Reference

*/ virtual Model::GetTransitGatewayPolicyTableAssociationsOutcome GetTransitGatewayPolicyTableAssociations(const Model::GetTransitGatewayPolicyTableAssociationsRequest& request) const; /** * A Callable wrapper for GetTransitGatewayPolicyTableAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTransitGatewayPolicyTableAssociationsOutcomeCallable GetTransitGatewayPolicyTableAssociationsCallable(const GetTransitGatewayPolicyTableAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::GetTransitGatewayPolicyTableAssociations, request); } /** * An Async wrapper for GetTransitGatewayPolicyTableAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTransitGatewayPolicyTableAssociationsAsync(const GetTransitGatewayPolicyTableAssociationsRequestT& request, const GetTransitGatewayPolicyTableAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetTransitGatewayPolicyTableAssociations, request, handler, context); } /** *

Returns a list of transit gateway policy table entries.

See * Also:

AWS * API Reference

*/ virtual Model::GetTransitGatewayPolicyTableEntriesOutcome GetTransitGatewayPolicyTableEntries(const Model::GetTransitGatewayPolicyTableEntriesRequest& request) const; /** * A Callable wrapper for GetTransitGatewayPolicyTableEntries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTransitGatewayPolicyTableEntriesOutcomeCallable GetTransitGatewayPolicyTableEntriesCallable(const GetTransitGatewayPolicyTableEntriesRequestT& request) const { return SubmitCallable(&EC2Client::GetTransitGatewayPolicyTableEntries, request); } /** * An Async wrapper for GetTransitGatewayPolicyTableEntries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTransitGatewayPolicyTableEntriesAsync(const GetTransitGatewayPolicyTableEntriesRequestT& request, const GetTransitGatewayPolicyTableEntriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetTransitGatewayPolicyTableEntries, request, handler, context); } /** *

Gets information about the prefix list references in a specified transit * gateway route table.

See Also:

AWS * API Reference

*/ virtual Model::GetTransitGatewayPrefixListReferencesOutcome GetTransitGatewayPrefixListReferences(const Model::GetTransitGatewayPrefixListReferencesRequest& request) const; /** * A Callable wrapper for GetTransitGatewayPrefixListReferences that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTransitGatewayPrefixListReferencesOutcomeCallable GetTransitGatewayPrefixListReferencesCallable(const GetTransitGatewayPrefixListReferencesRequestT& request) const { return SubmitCallable(&EC2Client::GetTransitGatewayPrefixListReferences, request); } /** * An Async wrapper for GetTransitGatewayPrefixListReferences that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTransitGatewayPrefixListReferencesAsync(const GetTransitGatewayPrefixListReferencesRequestT& request, const GetTransitGatewayPrefixListReferencesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetTransitGatewayPrefixListReferences, request, handler, context); } /** *

Gets information about the associations for the specified transit gateway * route table.

See Also:

AWS * API Reference

*/ virtual Model::GetTransitGatewayRouteTableAssociationsOutcome GetTransitGatewayRouteTableAssociations(const Model::GetTransitGatewayRouteTableAssociationsRequest& request) const; /** * A Callable wrapper for GetTransitGatewayRouteTableAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTransitGatewayRouteTableAssociationsOutcomeCallable GetTransitGatewayRouteTableAssociationsCallable(const GetTransitGatewayRouteTableAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::GetTransitGatewayRouteTableAssociations, request); } /** * An Async wrapper for GetTransitGatewayRouteTableAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTransitGatewayRouteTableAssociationsAsync(const GetTransitGatewayRouteTableAssociationsRequestT& request, const GetTransitGatewayRouteTableAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetTransitGatewayRouteTableAssociations, request, handler, context); } /** *

Gets information about the route table propagations for the specified transit * gateway route table.

See Also:

AWS * API Reference

*/ virtual Model::GetTransitGatewayRouteTablePropagationsOutcome GetTransitGatewayRouteTablePropagations(const Model::GetTransitGatewayRouteTablePropagationsRequest& request) const; /** * A Callable wrapper for GetTransitGatewayRouteTablePropagations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTransitGatewayRouteTablePropagationsOutcomeCallable GetTransitGatewayRouteTablePropagationsCallable(const GetTransitGatewayRouteTablePropagationsRequestT& request) const { return SubmitCallable(&EC2Client::GetTransitGatewayRouteTablePropagations, request); } /** * An Async wrapper for GetTransitGatewayRouteTablePropagations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTransitGatewayRouteTablePropagationsAsync(const GetTransitGatewayRouteTablePropagationsRequestT& request, const GetTransitGatewayRouteTablePropagationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetTransitGatewayRouteTablePropagations, request, handler, context); } /** *

Get the Verified Access policy associated with the endpoint.

See * Also:

AWS * API Reference

*/ virtual Model::GetVerifiedAccessEndpointPolicyOutcome GetVerifiedAccessEndpointPolicy(const Model::GetVerifiedAccessEndpointPolicyRequest& request) const; /** * A Callable wrapper for GetVerifiedAccessEndpointPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVerifiedAccessEndpointPolicyOutcomeCallable GetVerifiedAccessEndpointPolicyCallable(const GetVerifiedAccessEndpointPolicyRequestT& request) const { return SubmitCallable(&EC2Client::GetVerifiedAccessEndpointPolicy, request); } /** * An Async wrapper for GetVerifiedAccessEndpointPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVerifiedAccessEndpointPolicyAsync(const GetVerifiedAccessEndpointPolicyRequestT& request, const GetVerifiedAccessEndpointPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetVerifiedAccessEndpointPolicy, request, handler, context); } /** *

Shows the contents of the Verified Access policy associated with the * group.

See Also:

AWS * API Reference

*/ virtual Model::GetVerifiedAccessGroupPolicyOutcome GetVerifiedAccessGroupPolicy(const Model::GetVerifiedAccessGroupPolicyRequest& request) const; /** * A Callable wrapper for GetVerifiedAccessGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVerifiedAccessGroupPolicyOutcomeCallable GetVerifiedAccessGroupPolicyCallable(const GetVerifiedAccessGroupPolicyRequestT& request) const { return SubmitCallable(&EC2Client::GetVerifiedAccessGroupPolicy, request); } /** * An Async wrapper for GetVerifiedAccessGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVerifiedAccessGroupPolicyAsync(const GetVerifiedAccessGroupPolicyRequestT& request, const GetVerifiedAccessGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetVerifiedAccessGroupPolicy, request, handler, context); } /** *

Download an Amazon Web Services-provided sample configuration file to be used * with the customer gateway device specified for your Site-to-Site VPN * connection.

See Also:

AWS * API Reference

*/ virtual Model::GetVpnConnectionDeviceSampleConfigurationOutcome GetVpnConnectionDeviceSampleConfiguration(const Model::GetVpnConnectionDeviceSampleConfigurationRequest& request) const; /** * A Callable wrapper for GetVpnConnectionDeviceSampleConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVpnConnectionDeviceSampleConfigurationOutcomeCallable GetVpnConnectionDeviceSampleConfigurationCallable(const GetVpnConnectionDeviceSampleConfigurationRequestT& request) const { return SubmitCallable(&EC2Client::GetVpnConnectionDeviceSampleConfiguration, request); } /** * An Async wrapper for GetVpnConnectionDeviceSampleConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVpnConnectionDeviceSampleConfigurationAsync(const GetVpnConnectionDeviceSampleConfigurationRequestT& request, const GetVpnConnectionDeviceSampleConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetVpnConnectionDeviceSampleConfiguration, request, handler, context); } /** *

Obtain a list of customer gateway devices for which sample configuration * files can be provided. The request has no additional parameters. You can also * see the list of device types with sample configuration files available under Your customer * gateway device in the Amazon Web Services Site-to-Site VPN User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetVpnConnectionDeviceTypesOutcome GetVpnConnectionDeviceTypes(const Model::GetVpnConnectionDeviceTypesRequest& request) const; /** * A Callable wrapper for GetVpnConnectionDeviceTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVpnConnectionDeviceTypesOutcomeCallable GetVpnConnectionDeviceTypesCallable(const GetVpnConnectionDeviceTypesRequestT& request) const { return SubmitCallable(&EC2Client::GetVpnConnectionDeviceTypes, request); } /** * An Async wrapper for GetVpnConnectionDeviceTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVpnConnectionDeviceTypesAsync(const GetVpnConnectionDeviceTypesRequestT& request, const GetVpnConnectionDeviceTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetVpnConnectionDeviceTypes, request, handler, context); } /** *

Get details of available tunnel endpoint maintenance.

See * Also:

AWS * API Reference

*/ virtual Model::GetVpnTunnelReplacementStatusOutcome GetVpnTunnelReplacementStatus(const Model::GetVpnTunnelReplacementStatusRequest& request) const; /** * A Callable wrapper for GetVpnTunnelReplacementStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVpnTunnelReplacementStatusOutcomeCallable GetVpnTunnelReplacementStatusCallable(const GetVpnTunnelReplacementStatusRequestT& request) const { return SubmitCallable(&EC2Client::GetVpnTunnelReplacementStatus, request); } /** * An Async wrapper for GetVpnTunnelReplacementStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVpnTunnelReplacementStatusAsync(const GetVpnTunnelReplacementStatusRequestT& request, const GetVpnTunnelReplacementStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::GetVpnTunnelReplacementStatus, request, handler, context); } /** *

Uploads a client certificate revocation list to the specified Client VPN * endpoint. Uploading a client certificate revocation list overwrites the existing * client certificate revocation list.

Uploading a client certificate * revocation list resets existing client connections.

See Also:

* AWS * API Reference

*/ virtual Model::ImportClientVpnClientCertificateRevocationListOutcome ImportClientVpnClientCertificateRevocationList(const Model::ImportClientVpnClientCertificateRevocationListRequest& request) const; /** * A Callable wrapper for ImportClientVpnClientCertificateRevocationList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportClientVpnClientCertificateRevocationListOutcomeCallable ImportClientVpnClientCertificateRevocationListCallable(const ImportClientVpnClientCertificateRevocationListRequestT& request) const { return SubmitCallable(&EC2Client::ImportClientVpnClientCertificateRevocationList, request); } /** * An Async wrapper for ImportClientVpnClientCertificateRevocationList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportClientVpnClientCertificateRevocationListAsync(const ImportClientVpnClientCertificateRevocationListRequestT& request, const ImportClientVpnClientCertificateRevocationListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ImportClientVpnClientCertificateRevocationList, request, handler, context); } /** *

To import your virtual machines (VMs) with a console-based experience, * you can use the Import virtual machine images to Amazon Web Services * template in the Migration Hub * Orchestrator console. For more information, see the * Migration Hub Orchestrator User Guide .

Import single * or multi-volume disk images or EBS snapshots into an Amazon Machine Image * (AMI).

Amazon Web Services VM Import/Export strongly * recommends specifying a value for either the --license-type or * --usage-operation parameter when you create a new VM Import task. * This ensures your operating system is licensed appropriately and your billing is * optimized.

For more information, see Importing * a VM as an image using VM Import/Export in the VM Import/Export User * Guide.

See Also:

AWS API * Reference

*/ virtual Model::ImportImageOutcome ImportImage(const Model::ImportImageRequest& request) const; /** * A Callable wrapper for ImportImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportImageOutcomeCallable ImportImageCallable(const ImportImageRequestT& request) const { return SubmitCallable(&EC2Client::ImportImage, request); } /** * An Async wrapper for ImportImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportImageAsync(const ImportImageRequestT& request, const ImportImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ImportImage, request, handler, context); } /** *

We recommend that you use the * ImportImage API. For more information, see Importing * a VM as an image using VM Import/Export in the VM Import/Export User * Guide.

Creates an import instance task using metadata from * the specified disk image.

This API action is not supported by the Command * Line Interface (CLI). For information about using the Amazon EC2 CLI, which is * deprecated, see Importing * a VM to Amazon EC2 in the Amazon EC2 CLI Reference PDF file.

*

This API action supports only single-volume VMs. To import multi-volume VMs, * use ImportImage instead.

For information about the import manifest * referenced by this API action, see VM * Import Manifest.

See Also:

AWS * API Reference

*/ virtual Model::ImportInstanceOutcome ImportInstance(const Model::ImportInstanceRequest& request) const; /** * A Callable wrapper for ImportInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportInstanceOutcomeCallable ImportInstanceCallable(const ImportInstanceRequestT& request) const { return SubmitCallable(&EC2Client::ImportInstance, request); } /** * An Async wrapper for ImportInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportInstanceAsync(const ImportInstanceRequestT& request, const ImportInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ImportInstance, request, handler, context); } /** *

Imports the public key from an RSA or ED25519 key pair that you created with * a third-party tool. Compare this with CreateKeyPair, in which Amazon Web * Services creates the key pair and gives the keys to you (Amazon Web Services * keeps a copy of the public key). With ImportKeyPair, you create the key pair and * give Amazon Web Services just the public key. The private key is never * transferred between you and Amazon Web Services.

For more information * about key pairs, see Amazon * EC2 key pairs in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ImportKeyPairOutcome ImportKeyPair(const Model::ImportKeyPairRequest& request) const; /** * A Callable wrapper for ImportKeyPair that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportKeyPairOutcomeCallable ImportKeyPairCallable(const ImportKeyPairRequestT& request) const { return SubmitCallable(&EC2Client::ImportKeyPair, request); } /** * An Async wrapper for ImportKeyPair that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportKeyPairAsync(const ImportKeyPairRequestT& request, const ImportKeyPairResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ImportKeyPair, request, handler, context); } /** *

Imports a disk into an EBS snapshot.

For more information, see Importing * a disk as a snapshot using VM Import/Export in the VM Import/Export User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ImportSnapshotOutcome ImportSnapshot(const Model::ImportSnapshotRequest& request) const; /** * A Callable wrapper for ImportSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportSnapshotOutcomeCallable ImportSnapshotCallable(const ImportSnapshotRequestT& request) const { return SubmitCallable(&EC2Client::ImportSnapshot, request); } /** * An Async wrapper for ImportSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportSnapshotAsync(const ImportSnapshotRequestT& request, const ImportSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ImportSnapshot, request, handler, context); } /** *

Creates an import volume task using metadata from the specified disk * image.

This API action supports only single-volume VMs. To import * multi-volume VMs, use ImportImage instead. To import a disk to a * snapshot, use ImportSnapshot instead.

This API action is not * supported by the Command Line Interface (CLI). For information about using the * Amazon EC2 CLI, which is deprecated, see Importing * Disks to Amazon EBS in the Amazon EC2 CLI Reference PDF file.

*

For information about the import manifest referenced by this API action, see * VM * Import Manifest.

See Also:

AWS * API Reference

*/ virtual Model::ImportVolumeOutcome ImportVolume(const Model::ImportVolumeRequest& request) const; /** * A Callable wrapper for ImportVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportVolumeOutcomeCallable ImportVolumeCallable(const ImportVolumeRequestT& request) const { return SubmitCallable(&EC2Client::ImportVolume, request); } /** * An Async wrapper for ImportVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportVolumeAsync(const ImportVolumeRequestT& request, const ImportVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ImportVolume, request, handler, context); } /** *

Lists one or more AMIs that are currently in the Recycle Bin. For more * information, see Recycle * Bin in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListImagesInRecycleBinOutcome ListImagesInRecycleBin(const Model::ListImagesInRecycleBinRequest& request) const; /** * A Callable wrapper for ListImagesInRecycleBin that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListImagesInRecycleBinOutcomeCallable ListImagesInRecycleBinCallable(const ListImagesInRecycleBinRequestT& request) const { return SubmitCallable(&EC2Client::ListImagesInRecycleBin, request); } /** * An Async wrapper for ListImagesInRecycleBin that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListImagesInRecycleBinAsync(const ListImagesInRecycleBinRequestT& request, const ListImagesInRecycleBinResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ListImagesInRecycleBin, request, handler, context); } /** *

Lists one or more snapshots that are currently in the Recycle * Bin.

See Also:

AWS * API Reference

*/ virtual Model::ListSnapshotsInRecycleBinOutcome ListSnapshotsInRecycleBin(const Model::ListSnapshotsInRecycleBinRequest& request) const; /** * A Callable wrapper for ListSnapshotsInRecycleBin that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSnapshotsInRecycleBinOutcomeCallable ListSnapshotsInRecycleBinCallable(const ListSnapshotsInRecycleBinRequestT& request) const { return SubmitCallable(&EC2Client::ListSnapshotsInRecycleBin, request); } /** * An Async wrapper for ListSnapshotsInRecycleBin that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSnapshotsInRecycleBinAsync(const ListSnapshotsInRecycleBinRequestT& request, const ListSnapshotsInRecycleBinResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ListSnapshotsInRecycleBin, request, handler, context); } /** *

Modifies an attribute of the specified Elastic IP address. For requirements, * see Using * reverse DNS for email applications.

See Also:

AWS * API Reference

*/ virtual Model::ModifyAddressAttributeOutcome ModifyAddressAttribute(const Model::ModifyAddressAttributeRequest& request) const; /** * A Callable wrapper for ModifyAddressAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyAddressAttributeOutcomeCallable ModifyAddressAttributeCallable(const ModifyAddressAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyAddressAttribute, request); } /** * An Async wrapper for ModifyAddressAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyAddressAttributeAsync(const ModifyAddressAttributeRequestT& request, const ModifyAddressAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyAddressAttribute, request, handler, context); } /** *

Changes the opt-in status of the Local Zone and Wavelength Zone group for * your account.

Use * DescribeAvailabilityZones to view the value for * GroupName.

See Also:

AWS * API Reference

*/ virtual Model::ModifyAvailabilityZoneGroupOutcome ModifyAvailabilityZoneGroup(const Model::ModifyAvailabilityZoneGroupRequest& request) const; /** * A Callable wrapper for ModifyAvailabilityZoneGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyAvailabilityZoneGroupOutcomeCallable ModifyAvailabilityZoneGroupCallable(const ModifyAvailabilityZoneGroupRequestT& request) const { return SubmitCallable(&EC2Client::ModifyAvailabilityZoneGroup, request); } /** * An Async wrapper for ModifyAvailabilityZoneGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyAvailabilityZoneGroupAsync(const ModifyAvailabilityZoneGroupRequestT& request, const ModifyAvailabilityZoneGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyAvailabilityZoneGroup, request, handler, context); } /** *

Modifies a Capacity Reservation's capacity and the conditions under which it * is to be released. You cannot change a Capacity Reservation's instance type, EBS * optimization, instance store settings, platform, Availability Zone, or instance * eligibility. If you need to modify any of these attributes, we recommend that * you cancel the Capacity Reservation, and then create a new one with the required * attributes.

See Also:

AWS * API Reference

*/ virtual Model::ModifyCapacityReservationOutcome ModifyCapacityReservation(const Model::ModifyCapacityReservationRequest& request) const; /** * A Callable wrapper for ModifyCapacityReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCapacityReservationOutcomeCallable ModifyCapacityReservationCallable(const ModifyCapacityReservationRequestT& request) const { return SubmitCallable(&EC2Client::ModifyCapacityReservation, request); } /** * An Async wrapper for ModifyCapacityReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCapacityReservationAsync(const ModifyCapacityReservationRequestT& request, const ModifyCapacityReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyCapacityReservation, request, handler, context); } /** *

Modifies a Capacity Reservation Fleet.

When you modify the total * target capacity of a Capacity Reservation Fleet, the Fleet automatically creates * new Capacity Reservations, or modifies or cancels existing Capacity Reservations * in the Fleet to meet the new total target capacity. When you modify the end date * for the Fleet, the end dates for all of the individual Capacity Reservations in * the Fleet are updated accordingly.

See Also:

AWS * API Reference

*/ virtual Model::ModifyCapacityReservationFleetOutcome ModifyCapacityReservationFleet(const Model::ModifyCapacityReservationFleetRequest& request) const; /** * A Callable wrapper for ModifyCapacityReservationFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCapacityReservationFleetOutcomeCallable ModifyCapacityReservationFleetCallable(const ModifyCapacityReservationFleetRequestT& request) const { return SubmitCallable(&EC2Client::ModifyCapacityReservationFleet, request); } /** * An Async wrapper for ModifyCapacityReservationFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCapacityReservationFleetAsync(const ModifyCapacityReservationFleetRequestT& request, const ModifyCapacityReservationFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyCapacityReservationFleet, request, handler, context); } /** *

Modifies the specified Client VPN endpoint. Modifying the DNS server resets * existing client connections.

See Also:

AWS * API Reference

*/ virtual Model::ModifyClientVpnEndpointOutcome ModifyClientVpnEndpoint(const Model::ModifyClientVpnEndpointRequest& request) const; /** * A Callable wrapper for ModifyClientVpnEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClientVpnEndpointOutcomeCallable ModifyClientVpnEndpointCallable(const ModifyClientVpnEndpointRequestT& request) const { return SubmitCallable(&EC2Client::ModifyClientVpnEndpoint, request); } /** * An Async wrapper for ModifyClientVpnEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClientVpnEndpointAsync(const ModifyClientVpnEndpointRequestT& request, const ModifyClientVpnEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyClientVpnEndpoint, request, handler, context); } /** *

Modifies the default credit option for CPU usage of burstable performance * instances. The default credit option is set at the account level per Amazon Web * Services Region, and is specified per instance family. All new burstable * performance instances in the account launch using the default credit option.

*

ModifyDefaultCreditSpecification is an asynchronous operation, * which works at an Amazon Web Services Region level and modifies the credit * option for each Availability Zone. All zones in a Region are updated within five * minutes. But if instances are launched during this operation, they might not get * the new credit option until the zone is updated. To verify whether the update * has occurred, you can call GetDefaultCreditSpecification and check * DefaultCreditSpecification for updates.

For more * information, see Burstable * performance instances in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyDefaultCreditSpecificationOutcome ModifyDefaultCreditSpecification(const Model::ModifyDefaultCreditSpecificationRequest& request) const; /** * A Callable wrapper for ModifyDefaultCreditSpecification that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDefaultCreditSpecificationOutcomeCallable ModifyDefaultCreditSpecificationCallable(const ModifyDefaultCreditSpecificationRequestT& request) const { return SubmitCallable(&EC2Client::ModifyDefaultCreditSpecification, request); } /** * An Async wrapper for ModifyDefaultCreditSpecification that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDefaultCreditSpecificationAsync(const ModifyDefaultCreditSpecificationRequestT& request, const ModifyDefaultCreditSpecificationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyDefaultCreditSpecification, request, handler, context); } /** *

Changes the default KMS key for EBS encryption by default for your account in * this Region.

Amazon Web Services creates a unique Amazon Web Services * managed KMS key in each Region for use with encryption by default. If you change * the default KMS key to a symmetric customer managed KMS key, it is used instead * of the Amazon Web Services managed KMS key. To reset the default KMS key to the * Amazon Web Services managed KMS key for EBS, use ResetEbsDefaultKmsKeyId. * Amazon EBS does not support asymmetric KMS keys.

If you delete or disable * the customer managed KMS key that you specified for use with encryption by * default, your instances will fail to launch.

For more information, see Amazon * EBS encryption in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyEbsDefaultKmsKeyIdOutcome ModifyEbsDefaultKmsKeyId(const Model::ModifyEbsDefaultKmsKeyIdRequest& request) const; /** * A Callable wrapper for ModifyEbsDefaultKmsKeyId that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyEbsDefaultKmsKeyIdOutcomeCallable ModifyEbsDefaultKmsKeyIdCallable(const ModifyEbsDefaultKmsKeyIdRequestT& request) const { return SubmitCallable(&EC2Client::ModifyEbsDefaultKmsKeyId, request); } /** * An Async wrapper for ModifyEbsDefaultKmsKeyId that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyEbsDefaultKmsKeyIdAsync(const ModifyEbsDefaultKmsKeyIdRequestT& request, const ModifyEbsDefaultKmsKeyIdResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyEbsDefaultKmsKeyId, request, handler, context); } /** *

Modifies the specified EC2 Fleet.

You can only modify an EC2 Fleet * request of type maintain.

While the EC2 Fleet is being * modified, it is in the modifying state.

To scale up your EC2 * Fleet, increase its target capacity. The EC2 Fleet launches the additional Spot * Instances according to the allocation strategy for the EC2 Fleet request. If the * allocation strategy is lowest-price, the EC2 Fleet launches * instances using the Spot Instance pool with the lowest price. If the allocation * strategy is diversified, the EC2 Fleet distributes the instances * across the Spot Instance pools. If the allocation strategy is * capacity-optimized, EC2 Fleet launches instances from Spot Instance * pools with optimal capacity for the number of instances that are launching.

*

To scale down your EC2 Fleet, decrease its target capacity. First, the EC2 * Fleet cancels any open requests that exceed the new target capacity. You can * request that the EC2 Fleet terminate Spot Instances until the size of the fleet * no longer exceeds the new target capacity. If the allocation strategy is * lowest-price, the EC2 Fleet terminates the instances with the * highest price per unit. If the allocation strategy is * capacity-optimized, the EC2 Fleet terminates the instances in the * Spot Instance pools that have the least available Spot Instance capacity. If the * allocation strategy is diversified, the EC2 Fleet terminates * instances across the Spot Instance pools. Alternatively, you can request that * the EC2 Fleet keep the fleet at its current size, but not replace any Spot * Instances that are interrupted or that you terminate manually.

If you are * finished with your EC2 Fleet for now, but will use it again later, you can set * the target capacity to 0.

See Also:

AWS API * Reference

*/ virtual Model::ModifyFleetOutcome ModifyFleet(const Model::ModifyFleetRequest& request) const; /** * A Callable wrapper for ModifyFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyFleetOutcomeCallable ModifyFleetCallable(const ModifyFleetRequestT& request) const { return SubmitCallable(&EC2Client::ModifyFleet, request); } /** * An Async wrapper for ModifyFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyFleetAsync(const ModifyFleetRequestT& request, const ModifyFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyFleet, request, handler, context); } /** *

Modifies the specified attribute of the specified Amazon FPGA Image * (AFI).

See Also:

AWS * API Reference

*/ virtual Model::ModifyFpgaImageAttributeOutcome ModifyFpgaImageAttribute(const Model::ModifyFpgaImageAttributeRequest& request) const; /** * A Callable wrapper for ModifyFpgaImageAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyFpgaImageAttributeOutcomeCallable ModifyFpgaImageAttributeCallable(const ModifyFpgaImageAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyFpgaImageAttribute, request); } /** * An Async wrapper for ModifyFpgaImageAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyFpgaImageAttributeAsync(const ModifyFpgaImageAttributeRequestT& request, const ModifyFpgaImageAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyFpgaImageAttribute, request, handler, context); } /** *

Modify the auto-placement setting of a Dedicated Host. When auto-placement is * enabled, any instances that you launch with a tenancy of host but * without a specific host ID are placed onto any available Dedicated Host in your * account that has auto-placement enabled. When auto-placement is disabled, you * need to provide a host ID to have the instance launch onto a specific host. If * no host ID is provided, the instance is launched onto a suitable host with * auto-placement enabled.

You can also use this API action to modify a * Dedicated Host to support either multiple instance types in an instance family, * or to support a specific instance type only.

See Also:

AWS API * Reference

*/ virtual Model::ModifyHostsOutcome ModifyHosts(const Model::ModifyHostsRequest& request) const; /** * A Callable wrapper for ModifyHosts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyHostsOutcomeCallable ModifyHostsCallable(const ModifyHostsRequestT& request) const { return SubmitCallable(&EC2Client::ModifyHosts, request); } /** * An Async wrapper for ModifyHosts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyHostsAsync(const ModifyHostsRequestT& request, const ModifyHostsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyHosts, request, handler, context); } /** *

Modifies the ID format for the specified resource on a per-Region basis. You * can specify that resources should receive longer IDs (17-character IDs) when * they are created.

This request can only be used to modify longer ID * settings for resource types that are within the opt-in period. Resources * currently in their opt-in period include: bundle | * conversion-task | customer-gateway | * dhcp-options | elastic-ip-allocation | * elastic-ip-association | export-task | * flow-log | image | import-task | * internet-gateway | network-acl | * network-acl-association | network-interface | * network-interface-attachment | prefix-list | * route-table | route-table-association | * security-group | subnet | * subnet-cidr-block-association | vpc | * vpc-cidr-block-association | vpc-endpoint | * vpc-peering-connection | vpn-connection | * vpn-gateway.

This setting applies to the IAM user who makes * the request; it does not apply to the entire Amazon Web Services account. By * default, an IAM user defaults to the same settings as the root user. If you're * using this action as the root user, then these settings apply to the entire * account, unless an IAM user explicitly overrides these settings for themselves. * For more information, see Resource * IDs in the Amazon Elastic Compute Cloud User Guide.

Resources * created with longer IDs are visible to all IAM roles and users, regardless of * these settings and provided that they have permission to use the relevant * Describe command for the resource type.

See Also:

* AWS * API Reference

*/ virtual Model::ModifyIdFormatOutcome ModifyIdFormat(const Model::ModifyIdFormatRequest& request) const; /** * A Callable wrapper for ModifyIdFormat that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyIdFormatOutcomeCallable ModifyIdFormatCallable(const ModifyIdFormatRequestT& request) const { return SubmitCallable(&EC2Client::ModifyIdFormat, request); } /** * An Async wrapper for ModifyIdFormat that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyIdFormatAsync(const ModifyIdFormatRequestT& request, const ModifyIdFormatResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyIdFormat, request, handler, context); } /** *

Modifies the ID format of a resource for a specified IAM user, IAM role, or * the root user for an account; or all IAM users, IAM roles, and the root user for * an account. You can specify that resources should receive longer IDs * (17-character IDs) when they are created.

This request can only be used * to modify longer ID settings for resource types that are within the opt-in * period. Resources currently in their opt-in period include: bundle * | conversion-task | customer-gateway | * dhcp-options | elastic-ip-allocation | * elastic-ip-association | export-task | * flow-log | image | import-task | * internet-gateway | network-acl | * network-acl-association | network-interface | * network-interface-attachment | prefix-list | * route-table | route-table-association | * security-group | subnet | * subnet-cidr-block-association | vpc | * vpc-cidr-block-association | vpc-endpoint | * vpc-peering-connection | vpn-connection | * vpn-gateway.

For more information, see Resource * IDs in the Amazon Elastic Compute Cloud User Guide.

This * setting applies to the principal specified in the request; it does not apply to * the principal that makes the request.

Resources created with longer IDs * are visible to all IAM roles and users, regardless of these settings and * provided that they have permission to use the relevant Describe * command for the resource type.

See Also:

AWS * API Reference

*/ virtual Model::ModifyIdentityIdFormatOutcome ModifyIdentityIdFormat(const Model::ModifyIdentityIdFormatRequest& request) const; /** * A Callable wrapper for ModifyIdentityIdFormat that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyIdentityIdFormatOutcomeCallable ModifyIdentityIdFormatCallable(const ModifyIdentityIdFormatRequestT& request) const { return SubmitCallable(&EC2Client::ModifyIdentityIdFormat, request); } /** * An Async wrapper for ModifyIdentityIdFormat that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyIdentityIdFormatAsync(const ModifyIdentityIdFormatRequestT& request, const ModifyIdentityIdFormatResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyIdentityIdFormat, request, handler, context); } /** *

Modifies the specified attribute of the specified AMI. You can specify only * one attribute at a time.

To specify the attribute, you can use the * Attribute parameter, or one of the following parameters: * Description, ImdsSupport, or * LaunchPermission.

Images with an Amazon Web Services * Marketplace product code cannot be made public.

To enable the * SriovNetSupport enhanced networking attribute of an image, enable * SriovNetSupport on an instance and create an AMI from the * instance.

See Also:

AWS * API Reference

*/ virtual Model::ModifyImageAttributeOutcome ModifyImageAttribute(const Model::ModifyImageAttributeRequest& request) const; /** * A Callable wrapper for ModifyImageAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyImageAttributeOutcomeCallable ModifyImageAttributeCallable(const ModifyImageAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyImageAttribute, request); } /** * An Async wrapper for ModifyImageAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyImageAttributeAsync(const ModifyImageAttributeRequestT& request, const ModifyImageAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyImageAttribute, request, handler, context); } /** *

Modifies the specified attribute of the specified instance. You can specify * only one attribute at a time.

Note: Using this action to change * the security groups associated with an elastic network interface (ENI) attached * to an instance can result in an error if the instance has more than one ENI. To * change the security groups associated with an ENI attached to an instance that * has multiple ENIs, we recommend that you use the * ModifyNetworkInterfaceAttribute action.

To modify some attributes, * the instance must be stopped. For more information, see Modify * a stopped instance in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyInstanceAttributeOutcome ModifyInstanceAttribute(const Model::ModifyInstanceAttributeRequest& request) const; /** * A Callable wrapper for ModifyInstanceAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstanceAttributeOutcomeCallable ModifyInstanceAttributeCallable(const ModifyInstanceAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyInstanceAttribute, request); } /** * An Async wrapper for ModifyInstanceAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstanceAttributeAsync(const ModifyInstanceAttributeRequestT& request, const ModifyInstanceAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyInstanceAttribute, request, handler, context); } /** *

Modifies the Capacity Reservation settings for a stopped instance. Use this * action to configure an instance to target a specific Capacity Reservation, run * in any open Capacity Reservation with matching attributes, or run * On-Demand Instance capacity.

See Also:

AWS * API Reference

*/ virtual Model::ModifyInstanceCapacityReservationAttributesOutcome ModifyInstanceCapacityReservationAttributes(const Model::ModifyInstanceCapacityReservationAttributesRequest& request) const; /** * A Callable wrapper for ModifyInstanceCapacityReservationAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstanceCapacityReservationAttributesOutcomeCallable ModifyInstanceCapacityReservationAttributesCallable(const ModifyInstanceCapacityReservationAttributesRequestT& request) const { return SubmitCallable(&EC2Client::ModifyInstanceCapacityReservationAttributes, request); } /** * An Async wrapper for ModifyInstanceCapacityReservationAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstanceCapacityReservationAttributesAsync(const ModifyInstanceCapacityReservationAttributesRequestT& request, const ModifyInstanceCapacityReservationAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyInstanceCapacityReservationAttributes, request, handler, context); } /** *

Modifies the credit option for CPU usage on a running or stopped burstable * performance instance. The credit options are standard and * unlimited.

For more information, see Burstable * performance instances in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyInstanceCreditSpecificationOutcome ModifyInstanceCreditSpecification(const Model::ModifyInstanceCreditSpecificationRequest& request) const; /** * A Callable wrapper for ModifyInstanceCreditSpecification that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstanceCreditSpecificationOutcomeCallable ModifyInstanceCreditSpecificationCallable(const ModifyInstanceCreditSpecificationRequestT& request) const { return SubmitCallable(&EC2Client::ModifyInstanceCreditSpecification, request); } /** * An Async wrapper for ModifyInstanceCreditSpecification that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstanceCreditSpecificationAsync(const ModifyInstanceCreditSpecificationRequestT& request, const ModifyInstanceCreditSpecificationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyInstanceCreditSpecification, request, handler, context); } /** *

Modifies the start time for a scheduled Amazon EC2 instance * event.

See Also:

AWS * API Reference

*/ virtual Model::ModifyInstanceEventStartTimeOutcome ModifyInstanceEventStartTime(const Model::ModifyInstanceEventStartTimeRequest& request) const; /** * A Callable wrapper for ModifyInstanceEventStartTime that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstanceEventStartTimeOutcomeCallable ModifyInstanceEventStartTimeCallable(const ModifyInstanceEventStartTimeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyInstanceEventStartTime, request); } /** * An Async wrapper for ModifyInstanceEventStartTime that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstanceEventStartTimeAsync(const ModifyInstanceEventStartTimeRequestT& request, const ModifyInstanceEventStartTimeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyInstanceEventStartTime, request, handler, context); } /** *

Modifies the specified event window.

You can define either a set of * time ranges or a cron expression when modifying the event window, but not * both.

To modify the targets associated with the event window, use the * AssociateInstanceEventWindow and DisassociateInstanceEventWindow * API.

If Amazon Web Services has already scheduled an event, modifying an * event window won't change the time of the scheduled event.

For more * information, see Define * event windows for scheduled events in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyInstanceEventWindowOutcome ModifyInstanceEventWindow(const Model::ModifyInstanceEventWindowRequest& request) const; /** * A Callable wrapper for ModifyInstanceEventWindow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstanceEventWindowOutcomeCallable ModifyInstanceEventWindowCallable(const ModifyInstanceEventWindowRequestT& request) const { return SubmitCallable(&EC2Client::ModifyInstanceEventWindow, request); } /** * An Async wrapper for ModifyInstanceEventWindow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstanceEventWindowAsync(const ModifyInstanceEventWindowRequestT& request, const ModifyInstanceEventWindowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyInstanceEventWindow, request, handler, context); } /** *

Modifies the recovery behavior of your instance to disable simplified * automatic recovery or set the recovery behavior to default. The default * configuration will not enable simplified automatic recovery for an unsupported * instance type. For more information, see Simplified * automatic recovery.

See Also:

AWS * API Reference

*/ virtual Model::ModifyInstanceMaintenanceOptionsOutcome ModifyInstanceMaintenanceOptions(const Model::ModifyInstanceMaintenanceOptionsRequest& request) const; /** * A Callable wrapper for ModifyInstanceMaintenanceOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstanceMaintenanceOptionsOutcomeCallable ModifyInstanceMaintenanceOptionsCallable(const ModifyInstanceMaintenanceOptionsRequestT& request) const { return SubmitCallable(&EC2Client::ModifyInstanceMaintenanceOptions, request); } /** * An Async wrapper for ModifyInstanceMaintenanceOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstanceMaintenanceOptionsAsync(const ModifyInstanceMaintenanceOptionsRequestT& request, const ModifyInstanceMaintenanceOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyInstanceMaintenanceOptions, request, handler, context); } /** *

Modify the instance metadata parameters on a running or stopped instance. * When you modify the parameters on a stopped instance, they are applied when the * instance is started. When you modify the parameters on a running instance, the * API responds with a state of “pending”. After the parameter modifications are * successfully applied to the instance, the state of the modifications changes * from “pending” to “applied” in subsequent describe-instances API calls. For more * information, see Instance * metadata and user data in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyInstanceMetadataOptionsOutcome ModifyInstanceMetadataOptions(const Model::ModifyInstanceMetadataOptionsRequest& request) const; /** * A Callable wrapper for ModifyInstanceMetadataOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstanceMetadataOptionsOutcomeCallable ModifyInstanceMetadataOptionsCallable(const ModifyInstanceMetadataOptionsRequestT& request) const { return SubmitCallable(&EC2Client::ModifyInstanceMetadataOptions, request); } /** * An Async wrapper for ModifyInstanceMetadataOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstanceMetadataOptionsAsync(const ModifyInstanceMetadataOptionsRequestT& request, const ModifyInstanceMetadataOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyInstanceMetadataOptions, request, handler, context); } /** *

Modifies the placement attributes for a specified instance. You can do the * following:

  • Modify the affinity between an instance and a Dedicated * Host. When affinity is set to host and the instance is not * associated with a specific Dedicated Host, the next time the instance is * launched, it is automatically associated with the host on which it lands. If the * instance is restarted or rebooted, this relationship persists.

  • *

    Change the Dedicated Host with which an instance is associated.

    • *

  • Change the instance tenancy of an instance.

  • Move an * instance to or from a placement * group.

At least one attribute for affinity, host ID, * tenancy, or placement group name must be specified in the request. Affinity and * tenancy can be modified in the same request.

To modify the host ID, * tenancy, placement group, or partition for an instance, the instance must be in * the stopped state.

See Also:

AWS * API Reference

*/ virtual Model::ModifyInstancePlacementOutcome ModifyInstancePlacement(const Model::ModifyInstancePlacementRequest& request) const; /** * A Callable wrapper for ModifyInstancePlacement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyInstancePlacementOutcomeCallable ModifyInstancePlacementCallable(const ModifyInstancePlacementRequestT& request) const { return SubmitCallable(&EC2Client::ModifyInstancePlacement, request); } /** * An Async wrapper for ModifyInstancePlacement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyInstancePlacementAsync(const ModifyInstancePlacementRequestT& request, const ModifyInstancePlacementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyInstancePlacement, request, handler, context); } /** *

Modify the configurations of an IPAM.

See Also:

AWS API * Reference

*/ virtual Model::ModifyIpamOutcome ModifyIpam(const Model::ModifyIpamRequest& request) const; /** * A Callable wrapper for ModifyIpam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyIpamOutcomeCallable ModifyIpamCallable(const ModifyIpamRequestT& request) const { return SubmitCallable(&EC2Client::ModifyIpam, request); } /** * An Async wrapper for ModifyIpam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyIpamAsync(const ModifyIpamRequestT& request, const ModifyIpamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyIpam, request, handler, context); } /** *

Modify the configurations of an IPAM pool.

For more information, see * Modify * a pool in the Amazon VPC IPAM User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::ModifyIpamPoolOutcome ModifyIpamPool(const Model::ModifyIpamPoolRequest& request) const; /** * A Callable wrapper for ModifyIpamPool that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyIpamPoolOutcomeCallable ModifyIpamPoolCallable(const ModifyIpamPoolRequestT& request) const { return SubmitCallable(&EC2Client::ModifyIpamPool, request); } /** * An Async wrapper for ModifyIpamPool that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyIpamPoolAsync(const ModifyIpamPoolRequestT& request, const ModifyIpamPoolResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyIpamPool, request, handler, context); } /** *

Modify a resource CIDR. You can use this action to transfer resource CIDRs * between scopes and ignore resource CIDRs that you do not want to manage. If set * to false, the resource will not be tracked for overlap, it cannot be * auto-imported into a pool, and it will be removed from any pool it has an * allocation in.

For more information, see Move * resource CIDRs between scopes and Change * the monitoring state of resource CIDRs in the Amazon VPC IPAM User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyIpamResourceCidrOutcome ModifyIpamResourceCidr(const Model::ModifyIpamResourceCidrRequest& request) const; /** * A Callable wrapper for ModifyIpamResourceCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyIpamResourceCidrOutcomeCallable ModifyIpamResourceCidrCallable(const ModifyIpamResourceCidrRequestT& request) const { return SubmitCallable(&EC2Client::ModifyIpamResourceCidr, request); } /** * An Async wrapper for ModifyIpamResourceCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyIpamResourceCidrAsync(const ModifyIpamResourceCidrRequestT& request, const ModifyIpamResourceCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyIpamResourceCidr, request, handler, context); } /** *

Modifies a resource discovery. A resource discovery is an IPAM component that * enables IPAM to manage and monitor resources that belong to the owning * account.

See Also:

AWS * API Reference

*/ virtual Model::ModifyIpamResourceDiscoveryOutcome ModifyIpamResourceDiscovery(const Model::ModifyIpamResourceDiscoveryRequest& request) const; /** * A Callable wrapper for ModifyIpamResourceDiscovery that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyIpamResourceDiscoveryOutcomeCallable ModifyIpamResourceDiscoveryCallable(const ModifyIpamResourceDiscoveryRequestT& request) const { return SubmitCallable(&EC2Client::ModifyIpamResourceDiscovery, request); } /** * An Async wrapper for ModifyIpamResourceDiscovery that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyIpamResourceDiscoveryAsync(const ModifyIpamResourceDiscoveryRequestT& request, const ModifyIpamResourceDiscoveryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyIpamResourceDiscovery, request, handler, context); } /** *

Modify an IPAM scope.

See Also:

AWS * API Reference

*/ virtual Model::ModifyIpamScopeOutcome ModifyIpamScope(const Model::ModifyIpamScopeRequest& request) const; /** * A Callable wrapper for ModifyIpamScope that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyIpamScopeOutcomeCallable ModifyIpamScopeCallable(const ModifyIpamScopeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyIpamScope, request); } /** * An Async wrapper for ModifyIpamScope that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyIpamScopeAsync(const ModifyIpamScopeRequestT& request, const ModifyIpamScopeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyIpamScope, request, handler, context); } /** *

Modifies a launch template. You can specify which version of the launch * template to set as the default version. When launching an instance, the default * version applies when a launch template version is not specified.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyLaunchTemplateOutcome ModifyLaunchTemplate(const Model::ModifyLaunchTemplateRequest& request) const; /** * A Callable wrapper for ModifyLaunchTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyLaunchTemplateOutcomeCallable ModifyLaunchTemplateCallable(const ModifyLaunchTemplateRequestT& request) const { return SubmitCallable(&EC2Client::ModifyLaunchTemplate, request); } /** * An Async wrapper for ModifyLaunchTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyLaunchTemplateAsync(const ModifyLaunchTemplateRequestT& request, const ModifyLaunchTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyLaunchTemplate, request, handler, context); } /** *

Modifies the specified local gateway route.

See Also:

AWS * API Reference

*/ virtual Model::ModifyLocalGatewayRouteOutcome ModifyLocalGatewayRoute(const Model::ModifyLocalGatewayRouteRequest& request) const; /** * A Callable wrapper for ModifyLocalGatewayRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyLocalGatewayRouteOutcomeCallable ModifyLocalGatewayRouteCallable(const ModifyLocalGatewayRouteRequestT& request) const { return SubmitCallable(&EC2Client::ModifyLocalGatewayRoute, request); } /** * An Async wrapper for ModifyLocalGatewayRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyLocalGatewayRouteAsync(const ModifyLocalGatewayRouteRequestT& request, const ModifyLocalGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyLocalGatewayRoute, request, handler, context); } /** *

Modifies the specified managed prefix list.

Adding or removing entries * in a prefix list creates a new version of the prefix list. Changing the name of * the prefix list does not affect the version.

If you specify a current * version number that does not match the true current version number, the request * fails.

See Also:

AWS * API Reference

*/ virtual Model::ModifyManagedPrefixListOutcome ModifyManagedPrefixList(const Model::ModifyManagedPrefixListRequest& request) const; /** * A Callable wrapper for ModifyManagedPrefixList that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyManagedPrefixListOutcomeCallable ModifyManagedPrefixListCallable(const ModifyManagedPrefixListRequestT& request) const { return SubmitCallable(&EC2Client::ModifyManagedPrefixList, request); } /** * An Async wrapper for ModifyManagedPrefixList that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyManagedPrefixListAsync(const ModifyManagedPrefixListRequestT& request, const ModifyManagedPrefixListResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyManagedPrefixList, request, handler, context); } /** *

Modifies the specified network interface attribute. You can specify only one * attribute at a time. You can use this action to attach and detach security * groups from an existing EC2 instance.

See Also:

AWS * API Reference

*/ virtual Model::ModifyNetworkInterfaceAttributeOutcome ModifyNetworkInterfaceAttribute(const Model::ModifyNetworkInterfaceAttributeRequest& request) const; /** * A Callable wrapper for ModifyNetworkInterfaceAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyNetworkInterfaceAttributeOutcomeCallable ModifyNetworkInterfaceAttributeCallable(const ModifyNetworkInterfaceAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyNetworkInterfaceAttribute, request); } /** * An Async wrapper for ModifyNetworkInterfaceAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyNetworkInterfaceAttributeAsync(const ModifyNetworkInterfaceAttributeRequestT& request, const ModifyNetworkInterfaceAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyNetworkInterfaceAttribute, request, handler, context); } /** *

Modifies the options for instance hostnames for the specified * instance.

See Also:

AWS * API Reference

*/ virtual Model::ModifyPrivateDnsNameOptionsOutcome ModifyPrivateDnsNameOptions(const Model::ModifyPrivateDnsNameOptionsRequest& request) const; /** * A Callable wrapper for ModifyPrivateDnsNameOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyPrivateDnsNameOptionsOutcomeCallable ModifyPrivateDnsNameOptionsCallable(const ModifyPrivateDnsNameOptionsRequestT& request) const { return SubmitCallable(&EC2Client::ModifyPrivateDnsNameOptions, request); } /** * An Async wrapper for ModifyPrivateDnsNameOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyPrivateDnsNameOptionsAsync(const ModifyPrivateDnsNameOptionsRequestT& request, const ModifyPrivateDnsNameOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyPrivateDnsNameOptions, request, handler, context); } /** *

Modifies the configuration of your Reserved Instances, such as the * Availability Zone, instance count, or instance type. The Reserved Instances to * be modified must be identical, except for Availability Zone, network platform, * and instance type.

For more information, see Modifying * Reserved Instances in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyReservedInstancesOutcome ModifyReservedInstances(const Model::ModifyReservedInstancesRequest& request) const; /** * A Callable wrapper for ModifyReservedInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyReservedInstancesOutcomeCallable ModifyReservedInstancesCallable(const ModifyReservedInstancesRequestT& request) const { return SubmitCallable(&EC2Client::ModifyReservedInstances, request); } /** * An Async wrapper for ModifyReservedInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyReservedInstancesAsync(const ModifyReservedInstancesRequestT& request, const ModifyReservedInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyReservedInstances, request, handler, context); } /** *

Modifies the rules of a security group.

See Also:

AWS * API Reference

*/ virtual Model::ModifySecurityGroupRulesOutcome ModifySecurityGroupRules(const Model::ModifySecurityGroupRulesRequest& request) const; /** * A Callable wrapper for ModifySecurityGroupRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifySecurityGroupRulesOutcomeCallable ModifySecurityGroupRulesCallable(const ModifySecurityGroupRulesRequestT& request) const { return SubmitCallable(&EC2Client::ModifySecurityGroupRules, request); } /** * An Async wrapper for ModifySecurityGroupRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifySecurityGroupRulesAsync(const ModifySecurityGroupRulesRequestT& request, const ModifySecurityGroupRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifySecurityGroupRules, request, handler, context); } /** *

Adds or removes permission settings for the specified snapshot. You may add * or remove specified Amazon Web Services account IDs from a snapshot's list of * create volume permissions, but you cannot do both in a single operation. If you * need to both add and remove account IDs for a snapshot, you must use multiple * operations. You can make up to 500 modifications to a snapshot in a single * operation.

Encrypted snapshots and snapshots with Amazon Web Services * Marketplace product codes cannot be made public. Snapshots encrypted with your * default KMS key cannot be shared with other accounts.

For more * information about modifying snapshot permissions, see Share * a snapshot in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifySnapshotAttributeOutcome ModifySnapshotAttribute(const Model::ModifySnapshotAttributeRequest& request) const; /** * A Callable wrapper for ModifySnapshotAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifySnapshotAttributeOutcomeCallable ModifySnapshotAttributeCallable(const ModifySnapshotAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ModifySnapshotAttribute, request); } /** * An Async wrapper for ModifySnapshotAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifySnapshotAttributeAsync(const ModifySnapshotAttributeRequestT& request, const ModifySnapshotAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifySnapshotAttribute, request, handler, context); } /** *

Archives an Amazon EBS snapshot. When you archive a snapshot, it is converted * to a full snapshot that includes all of the blocks of data that were written to * the volume at the time the snapshot was created, and moved from the standard * tier to the archive tier. For more information, see Archive * Amazon EBS snapshots in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifySnapshotTierOutcome ModifySnapshotTier(const Model::ModifySnapshotTierRequest& request) const; /** * A Callable wrapper for ModifySnapshotTier that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifySnapshotTierOutcomeCallable ModifySnapshotTierCallable(const ModifySnapshotTierRequestT& request) const { return SubmitCallable(&EC2Client::ModifySnapshotTier, request); } /** * An Async wrapper for ModifySnapshotTier that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifySnapshotTierAsync(const ModifySnapshotTierRequestT& request, const ModifySnapshotTierResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifySnapshotTier, request, handler, context); } /** *

Modifies the specified Spot Fleet request.

You can only modify a Spot * Fleet request of type maintain.

While the Spot Fleet request * is being modified, it is in the modifying state.

To scale up * your Spot Fleet, increase its target capacity. The Spot Fleet launches the * additional Spot Instances according to the allocation strategy for the Spot * Fleet request. If the allocation strategy is lowestPrice, the Spot * Fleet launches instances using the Spot Instance pool with the lowest price. If * the allocation strategy is diversified, the Spot Fleet distributes * the instances across the Spot Instance pools. If the allocation strategy is * capacityOptimized, Spot Fleet launches instances from Spot Instance * pools with optimal capacity for the number of instances that are launching.

*

To scale down your Spot Fleet, decrease its target capacity. First, the Spot * Fleet cancels any open requests that exceed the new target capacity. You can * request that the Spot Fleet terminate Spot Instances until the size of the fleet * no longer exceeds the new target capacity. If the allocation strategy is * lowestPrice, the Spot Fleet terminates the instances with the * highest price per unit. If the allocation strategy is * capacityOptimized, the Spot Fleet terminates the instances in the * Spot Instance pools that have the least available Spot Instance capacity. If the * allocation strategy is diversified, the Spot Fleet terminates * instances across the Spot Instance pools. Alternatively, you can request that * the Spot Fleet keep the fleet at its current size, but not replace any Spot * Instances that are interrupted or that you terminate manually.

If you are * finished with your Spot Fleet for now, but will use it again later, you can set * the target capacity to 0.

See Also:

AWS * API Reference

*/ virtual Model::ModifySpotFleetRequestOutcome ModifySpotFleetRequest(const Model::ModifySpotFleetRequestRequest& request) const; /** * A Callable wrapper for ModifySpotFleetRequest that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifySpotFleetRequestOutcomeCallable ModifySpotFleetRequestCallable(const ModifySpotFleetRequestRequestT& request) const { return SubmitCallable(&EC2Client::ModifySpotFleetRequest, request); } /** * An Async wrapper for ModifySpotFleetRequest that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifySpotFleetRequestAsync(const ModifySpotFleetRequestRequestT& request, const ModifySpotFleetRequestResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifySpotFleetRequest, request, handler, context); } /** *

Modifies a subnet attribute. You can only modify one attribute at a time.

*

Use this action to modify subnets on Amazon Web Services Outposts.

    *

  • To modify a subnet on an Outpost rack, set both * MapCustomerOwnedIpOnLaunch and CustomerOwnedIpv4Pool. * These two parameters act as a single attribute.

  • To modify a * subnet on an Outpost server, set either EnableLniAtDeviceIndex or * DisableLniAtDeviceIndex.

For more information * about Amazon Web Services Outposts, see the following:

See Also:

AWS * API Reference

*/ virtual Model::ModifySubnetAttributeOutcome ModifySubnetAttribute(const Model::ModifySubnetAttributeRequest& request) const; /** * A Callable wrapper for ModifySubnetAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifySubnetAttributeOutcomeCallable ModifySubnetAttributeCallable(const ModifySubnetAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ModifySubnetAttribute, request); } /** * An Async wrapper for ModifySubnetAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifySubnetAttributeAsync(const ModifySubnetAttributeRequestT& request, const ModifySubnetAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifySubnetAttribute, request, handler, context); } /** *

Allows or restricts mirroring network services.

By default, Amazon * DNS network services are not eligible for Traffic Mirror. Use * AddNetworkServices to add network services to a Traffic Mirror * filter. When a network service is added to the Traffic Mirror filter, all * traffic related to that network service will be mirrored. When you no longer * want to mirror network services, use RemoveNetworkServices to * remove the network services from the Traffic Mirror filter.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyTrafficMirrorFilterNetworkServicesOutcome ModifyTrafficMirrorFilterNetworkServices(const Model::ModifyTrafficMirrorFilterNetworkServicesRequest& request) const; /** * A Callable wrapper for ModifyTrafficMirrorFilterNetworkServices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyTrafficMirrorFilterNetworkServicesOutcomeCallable ModifyTrafficMirrorFilterNetworkServicesCallable(const ModifyTrafficMirrorFilterNetworkServicesRequestT& request) const { return SubmitCallable(&EC2Client::ModifyTrafficMirrorFilterNetworkServices, request); } /** * An Async wrapper for ModifyTrafficMirrorFilterNetworkServices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyTrafficMirrorFilterNetworkServicesAsync(const ModifyTrafficMirrorFilterNetworkServicesRequestT& request, const ModifyTrafficMirrorFilterNetworkServicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyTrafficMirrorFilterNetworkServices, request, handler, context); } /** *

Modifies the specified Traffic Mirror rule.

* DestinationCidrBlock and SourceCidrBlock must both be * an IPv4 range or an IPv6 range.

See Also:

AWS * API Reference

*/ virtual Model::ModifyTrafficMirrorFilterRuleOutcome ModifyTrafficMirrorFilterRule(const Model::ModifyTrafficMirrorFilterRuleRequest& request) const; /** * A Callable wrapper for ModifyTrafficMirrorFilterRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyTrafficMirrorFilterRuleOutcomeCallable ModifyTrafficMirrorFilterRuleCallable(const ModifyTrafficMirrorFilterRuleRequestT& request) const { return SubmitCallable(&EC2Client::ModifyTrafficMirrorFilterRule, request); } /** * An Async wrapper for ModifyTrafficMirrorFilterRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyTrafficMirrorFilterRuleAsync(const ModifyTrafficMirrorFilterRuleRequestT& request, const ModifyTrafficMirrorFilterRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyTrafficMirrorFilterRule, request, handler, context); } /** *

Modifies a Traffic Mirror session.

See Also:

AWS * API Reference

*/ virtual Model::ModifyTrafficMirrorSessionOutcome ModifyTrafficMirrorSession(const Model::ModifyTrafficMirrorSessionRequest& request) const; /** * A Callable wrapper for ModifyTrafficMirrorSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyTrafficMirrorSessionOutcomeCallable ModifyTrafficMirrorSessionCallable(const ModifyTrafficMirrorSessionRequestT& request) const { return SubmitCallable(&EC2Client::ModifyTrafficMirrorSession, request); } /** * An Async wrapper for ModifyTrafficMirrorSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyTrafficMirrorSessionAsync(const ModifyTrafficMirrorSessionRequestT& request, const ModifyTrafficMirrorSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyTrafficMirrorSession, request, handler, context); } /** *

Modifies the specified transit gateway. When you modify a transit gateway, * the modified options are applied to new transit gateway attachments only. Your * existing transit gateway attachments are not modified.

See Also:

* AWS * API Reference

*/ virtual Model::ModifyTransitGatewayOutcome ModifyTransitGateway(const Model::ModifyTransitGatewayRequest& request) const; /** * A Callable wrapper for ModifyTransitGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyTransitGatewayOutcomeCallable ModifyTransitGatewayCallable(const ModifyTransitGatewayRequestT& request) const { return SubmitCallable(&EC2Client::ModifyTransitGateway, request); } /** * An Async wrapper for ModifyTransitGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyTransitGatewayAsync(const ModifyTransitGatewayRequestT& request, const ModifyTransitGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyTransitGateway, request, handler, context); } /** *

Modifies a reference (route) to a prefix list in a specified transit gateway * route table.

See Also:

AWS * API Reference

*/ virtual Model::ModifyTransitGatewayPrefixListReferenceOutcome ModifyTransitGatewayPrefixListReference(const Model::ModifyTransitGatewayPrefixListReferenceRequest& request) const; /** * A Callable wrapper for ModifyTransitGatewayPrefixListReference that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyTransitGatewayPrefixListReferenceOutcomeCallable ModifyTransitGatewayPrefixListReferenceCallable(const ModifyTransitGatewayPrefixListReferenceRequestT& request) const { return SubmitCallable(&EC2Client::ModifyTransitGatewayPrefixListReference, request); } /** * An Async wrapper for ModifyTransitGatewayPrefixListReference that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyTransitGatewayPrefixListReferenceAsync(const ModifyTransitGatewayPrefixListReferenceRequestT& request, const ModifyTransitGatewayPrefixListReferenceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyTransitGatewayPrefixListReference, request, handler, context); } /** *

Modifies the specified VPC attachment.

See Also:

AWS * API Reference

*/ virtual Model::ModifyTransitGatewayVpcAttachmentOutcome ModifyTransitGatewayVpcAttachment(const Model::ModifyTransitGatewayVpcAttachmentRequest& request) const; /** * A Callable wrapper for ModifyTransitGatewayVpcAttachment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyTransitGatewayVpcAttachmentOutcomeCallable ModifyTransitGatewayVpcAttachmentCallable(const ModifyTransitGatewayVpcAttachmentRequestT& request) const { return SubmitCallable(&EC2Client::ModifyTransitGatewayVpcAttachment, request); } /** * An Async wrapper for ModifyTransitGatewayVpcAttachment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyTransitGatewayVpcAttachmentAsync(const ModifyTransitGatewayVpcAttachmentRequestT& request, const ModifyTransitGatewayVpcAttachmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyTransitGatewayVpcAttachment, request, handler, context); } /** *

Modifies the configuration of the specified Amazon Web Services Verified * Access endpoint.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVerifiedAccessEndpointOutcome ModifyVerifiedAccessEndpoint(const Model::ModifyVerifiedAccessEndpointRequest& request) const; /** * A Callable wrapper for ModifyVerifiedAccessEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVerifiedAccessEndpointOutcomeCallable ModifyVerifiedAccessEndpointCallable(const ModifyVerifiedAccessEndpointRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVerifiedAccessEndpoint, request); } /** * An Async wrapper for ModifyVerifiedAccessEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVerifiedAccessEndpointAsync(const ModifyVerifiedAccessEndpointRequestT& request, const ModifyVerifiedAccessEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVerifiedAccessEndpoint, request, handler, context); } /** *

Modifies the specified Amazon Web Services Verified Access endpoint * policy.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVerifiedAccessEndpointPolicyOutcome ModifyVerifiedAccessEndpointPolicy(const Model::ModifyVerifiedAccessEndpointPolicyRequest& request) const; /** * A Callable wrapper for ModifyVerifiedAccessEndpointPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVerifiedAccessEndpointPolicyOutcomeCallable ModifyVerifiedAccessEndpointPolicyCallable(const ModifyVerifiedAccessEndpointPolicyRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVerifiedAccessEndpointPolicy, request); } /** * An Async wrapper for ModifyVerifiedAccessEndpointPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVerifiedAccessEndpointPolicyAsync(const ModifyVerifiedAccessEndpointPolicyRequestT& request, const ModifyVerifiedAccessEndpointPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVerifiedAccessEndpointPolicy, request, handler, context); } /** *

Modifies the specified Amazon Web Services Verified Access group * configuration.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVerifiedAccessGroupOutcome ModifyVerifiedAccessGroup(const Model::ModifyVerifiedAccessGroupRequest& request) const; /** * A Callable wrapper for ModifyVerifiedAccessGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVerifiedAccessGroupOutcomeCallable ModifyVerifiedAccessGroupCallable(const ModifyVerifiedAccessGroupRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVerifiedAccessGroup, request); } /** * An Async wrapper for ModifyVerifiedAccessGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVerifiedAccessGroupAsync(const ModifyVerifiedAccessGroupRequestT& request, const ModifyVerifiedAccessGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVerifiedAccessGroup, request, handler, context); } /** *

Modifies the specified Amazon Web Services Verified Access group * policy.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVerifiedAccessGroupPolicyOutcome ModifyVerifiedAccessGroupPolicy(const Model::ModifyVerifiedAccessGroupPolicyRequest& request) const; /** * A Callable wrapper for ModifyVerifiedAccessGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVerifiedAccessGroupPolicyOutcomeCallable ModifyVerifiedAccessGroupPolicyCallable(const ModifyVerifiedAccessGroupPolicyRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVerifiedAccessGroupPolicy, request); } /** * An Async wrapper for ModifyVerifiedAccessGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVerifiedAccessGroupPolicyAsync(const ModifyVerifiedAccessGroupPolicyRequestT& request, const ModifyVerifiedAccessGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVerifiedAccessGroupPolicy, request, handler, context); } /** *

Modifies the configuration of the specified Amazon Web Services Verified * Access instance.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVerifiedAccessInstanceOutcome ModifyVerifiedAccessInstance(const Model::ModifyVerifiedAccessInstanceRequest& request) const; /** * A Callable wrapper for ModifyVerifiedAccessInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVerifiedAccessInstanceOutcomeCallable ModifyVerifiedAccessInstanceCallable(const ModifyVerifiedAccessInstanceRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVerifiedAccessInstance, request); } /** * An Async wrapper for ModifyVerifiedAccessInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVerifiedAccessInstanceAsync(const ModifyVerifiedAccessInstanceRequestT& request, const ModifyVerifiedAccessInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVerifiedAccessInstance, request, handler, context); } /** *

Modifies the logging configuration for the specified Amazon Web Services * Verified Access instance.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVerifiedAccessInstanceLoggingConfigurationOutcome ModifyVerifiedAccessInstanceLoggingConfiguration(const Model::ModifyVerifiedAccessInstanceLoggingConfigurationRequest& request) const; /** * A Callable wrapper for ModifyVerifiedAccessInstanceLoggingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVerifiedAccessInstanceLoggingConfigurationOutcomeCallable ModifyVerifiedAccessInstanceLoggingConfigurationCallable(const ModifyVerifiedAccessInstanceLoggingConfigurationRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVerifiedAccessInstanceLoggingConfiguration, request); } /** * An Async wrapper for ModifyVerifiedAccessInstanceLoggingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVerifiedAccessInstanceLoggingConfigurationAsync(const ModifyVerifiedAccessInstanceLoggingConfigurationRequestT& request, const ModifyVerifiedAccessInstanceLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVerifiedAccessInstanceLoggingConfiguration, request, handler, context); } /** *

Modifies the configuration of the specified Amazon Web Services Verified * Access trust provider.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVerifiedAccessTrustProviderOutcome ModifyVerifiedAccessTrustProvider(const Model::ModifyVerifiedAccessTrustProviderRequest& request) const; /** * A Callable wrapper for ModifyVerifiedAccessTrustProvider that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVerifiedAccessTrustProviderOutcomeCallable ModifyVerifiedAccessTrustProviderCallable(const ModifyVerifiedAccessTrustProviderRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVerifiedAccessTrustProvider, request); } /** * An Async wrapper for ModifyVerifiedAccessTrustProvider that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVerifiedAccessTrustProviderAsync(const ModifyVerifiedAccessTrustProviderRequestT& request, const ModifyVerifiedAccessTrustProviderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVerifiedAccessTrustProvider, request, handler, context); } /** *

You can modify several parameters of an existing EBS volume, including volume * size, volume type, and IOPS capacity. If your EBS volume is attached to a * current-generation EC2 instance type, you might be able to apply these changes * without stopping the instance or detaching the volume from it. For more * information about modifying EBS volumes, see Amazon * EBS Elastic Volumes (Linux instances) or Amazon * EBS Elastic Volumes (Windows instances).

When you complete a resize * operation on your volume, you need to extend the volume's file-system size to * take advantage of the new storage capacity. For more information, see Extend * a Linux file system or Extend * a Windows file system.

You can use CloudWatch Events to check the * status of a modification to an EBS volume. For information about CloudWatch * Events, see the Amazon * CloudWatch Events User Guide. You can also track the status of a * modification using DescribeVolumesModifications. For information about * tracking status changes using either method, see Monitor * the progress of volume modifications.

With previous-generation * instance types, resizing an EBS volume might require detaching and reattaching * the volume or stopping and restarting the instance.

After modifying a * volume, you must wait at least six hours and ensure that the volume is in the * in-use or available state before you can modify the * same volume. This is sometimes referred to as a cooldown period.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyVolumeOutcome ModifyVolume(const Model::ModifyVolumeRequest& request) const; /** * A Callable wrapper for ModifyVolume that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVolumeOutcomeCallable ModifyVolumeCallable(const ModifyVolumeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVolume, request); } /** * An Async wrapper for ModifyVolume that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVolumeAsync(const ModifyVolumeRequestT& request, const ModifyVolumeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVolume, request, handler, context); } /** *

Modifies a volume attribute.

By default, all I/O operations for the * volume are suspended when the data on the volume is determined to be potentially * inconsistent, to prevent undetectable, latent data corruption. The I/O access to * the volume can be resumed by first enabling I/O access and then checking the * data consistency on your volume.

You can change the default behavior to * resume I/O operations. We recommend that you change this only for boot volumes * or for volumes that are stateless or disposable.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVolumeAttributeOutcome ModifyVolumeAttribute(const Model::ModifyVolumeAttributeRequest& request) const; /** * A Callable wrapper for ModifyVolumeAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVolumeAttributeOutcomeCallable ModifyVolumeAttributeCallable(const ModifyVolumeAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVolumeAttribute, request); } /** * An Async wrapper for ModifyVolumeAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVolumeAttributeAsync(const ModifyVolumeAttributeRequestT& request, const ModifyVolumeAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVolumeAttribute, request, handler, context); } /** *

Modifies the specified attribute of the specified VPC.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyVpcAttributeOutcome ModifyVpcAttribute(const Model::ModifyVpcAttributeRequest& request) const; /** * A Callable wrapper for ModifyVpcAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpcAttributeOutcomeCallable ModifyVpcAttributeCallable(const ModifyVpcAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpcAttribute, request); } /** * An Async wrapper for ModifyVpcAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpcAttributeAsync(const ModifyVpcAttributeRequestT& request, const ModifyVpcAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpcAttribute, request, handler, context); } /** *

Modifies attributes of a specified VPC endpoint. The attributes that you can * modify depend on the type of VPC endpoint (interface, gateway, or Gateway Load * Balancer). For more information, see the Amazon Web Services * PrivateLink Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpcEndpointOutcome ModifyVpcEndpoint(const Model::ModifyVpcEndpointRequest& request) const; /** * A Callable wrapper for ModifyVpcEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpcEndpointOutcomeCallable ModifyVpcEndpointCallable(const ModifyVpcEndpointRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpcEndpoint, request); } /** * An Async wrapper for ModifyVpcEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpcEndpointAsync(const ModifyVpcEndpointRequestT& request, const ModifyVpcEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpcEndpoint, request, handler, context); } /** *

Modifies a connection notification for VPC endpoint or VPC endpoint service. * You can change the SNS topic for the notification, or the events for which to be * notified.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpcEndpointConnectionNotificationOutcome ModifyVpcEndpointConnectionNotification(const Model::ModifyVpcEndpointConnectionNotificationRequest& request) const; /** * A Callable wrapper for ModifyVpcEndpointConnectionNotification that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpcEndpointConnectionNotificationOutcomeCallable ModifyVpcEndpointConnectionNotificationCallable(const ModifyVpcEndpointConnectionNotificationRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpcEndpointConnectionNotification, request); } /** * An Async wrapper for ModifyVpcEndpointConnectionNotification that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpcEndpointConnectionNotificationAsync(const ModifyVpcEndpointConnectionNotificationRequestT& request, const ModifyVpcEndpointConnectionNotificationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpcEndpointConnectionNotification, request, handler, context); } /** *

Modifies the attributes of your VPC endpoint service configuration. You can * change the Network Load Balancers or Gateway Load Balancers for your service, * and you can specify whether acceptance is required for requests to connect to * your endpoint service through an interface VPC endpoint.

If you set or * modify the private DNS name, you must prove that you own the private DNS domain * name.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpcEndpointServiceConfigurationOutcome ModifyVpcEndpointServiceConfiguration(const Model::ModifyVpcEndpointServiceConfigurationRequest& request) const; /** * A Callable wrapper for ModifyVpcEndpointServiceConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpcEndpointServiceConfigurationOutcomeCallable ModifyVpcEndpointServiceConfigurationCallable(const ModifyVpcEndpointServiceConfigurationRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpcEndpointServiceConfiguration, request); } /** * An Async wrapper for ModifyVpcEndpointServiceConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpcEndpointServiceConfigurationAsync(const ModifyVpcEndpointServiceConfigurationRequestT& request, const ModifyVpcEndpointServiceConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpcEndpointServiceConfiguration, request, handler, context); } /** *

Modifies the payer responsibility for your VPC endpoint * service.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpcEndpointServicePayerResponsibilityOutcome ModifyVpcEndpointServicePayerResponsibility(const Model::ModifyVpcEndpointServicePayerResponsibilityRequest& request) const; /** * A Callable wrapper for ModifyVpcEndpointServicePayerResponsibility that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpcEndpointServicePayerResponsibilityOutcomeCallable ModifyVpcEndpointServicePayerResponsibilityCallable(const ModifyVpcEndpointServicePayerResponsibilityRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpcEndpointServicePayerResponsibility, request); } /** * An Async wrapper for ModifyVpcEndpointServicePayerResponsibility that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpcEndpointServicePayerResponsibilityAsync(const ModifyVpcEndpointServicePayerResponsibilityRequestT& request, const ModifyVpcEndpointServicePayerResponsibilityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpcEndpointServicePayerResponsibility, request, handler, context); } /** *

Modifies the permissions for your VPC endpoint service. You can add or remove * permissions for service consumers (Amazon Web Services accounts, users, and IAM * roles) to connect to your endpoint service.

If you grant permissions to * all principals, the service is public. Any users who know the name of a public * service can send a request to attach an endpoint. If the service does not * require manual approval, attachments are automatically approved.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyVpcEndpointServicePermissionsOutcome ModifyVpcEndpointServicePermissions(const Model::ModifyVpcEndpointServicePermissionsRequest& request) const; /** * A Callable wrapper for ModifyVpcEndpointServicePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpcEndpointServicePermissionsOutcomeCallable ModifyVpcEndpointServicePermissionsCallable(const ModifyVpcEndpointServicePermissionsRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpcEndpointServicePermissions, request); } /** * An Async wrapper for ModifyVpcEndpointServicePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpcEndpointServicePermissionsAsync(const ModifyVpcEndpointServicePermissionsRequestT& request, const ModifyVpcEndpointServicePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpcEndpointServicePermissions, request, handler, context); } /** *

Modifies the VPC peering connection options on one side of a VPC peering * connection.

If the peered VPCs are in the same Amazon Web Services * account, you can enable DNS resolution for queries from the local VPC. This * ensures that queries from the local VPC resolve to private IP addresses in the * peer VPC. This option is not available if the peered VPCs are in different * Amazon Web Services accounts or different Regions. For peered VPCs in different * Amazon Web Services accounts, each Amazon Web Services account owner must * initiate a separate request to modify the peering connection options. For * inter-region peering connections, you must use the Region for the requester VPC * to modify the requester VPC peering options and the Region for the accepter VPC * to modify the accepter VPC peering options. To verify which VPCs are the * accepter and the requester for a VPC peering connection, use the * DescribeVpcPeeringConnections command.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpcPeeringConnectionOptionsOutcome ModifyVpcPeeringConnectionOptions(const Model::ModifyVpcPeeringConnectionOptionsRequest& request) const; /** * A Callable wrapper for ModifyVpcPeeringConnectionOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpcPeeringConnectionOptionsOutcomeCallable ModifyVpcPeeringConnectionOptionsCallable(const ModifyVpcPeeringConnectionOptionsRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpcPeeringConnectionOptions, request); } /** * An Async wrapper for ModifyVpcPeeringConnectionOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpcPeeringConnectionOptionsAsync(const ModifyVpcPeeringConnectionOptionsRequestT& request, const ModifyVpcPeeringConnectionOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpcPeeringConnectionOptions, request, handler, context); } /** *

Modifies the instance tenancy attribute of the specified VPC. You can change * the instance tenancy attribute of a VPC to default only. You cannot * change the instance tenancy attribute to dedicated.

After * you modify the tenancy of the VPC, any new instances that you launch into the * VPC have a tenancy of default, unless you specify otherwise during * launch. The tenancy of any existing instances in the VPC is not affected.

*

For more information, see Dedicated * Instances in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpcTenancyOutcome ModifyVpcTenancy(const Model::ModifyVpcTenancyRequest& request) const; /** * A Callable wrapper for ModifyVpcTenancy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpcTenancyOutcomeCallable ModifyVpcTenancyCallable(const ModifyVpcTenancyRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpcTenancy, request); } /** * An Async wrapper for ModifyVpcTenancy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpcTenancyAsync(const ModifyVpcTenancyRequestT& request, const ModifyVpcTenancyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpcTenancy, request, handler, context); } /** *

Modifies the customer gateway or the target gateway of an Amazon Web Services * Site-to-Site VPN connection. To modify the target gateway, the following * migration options are available:

  • An existing virtual private * gateway to a new virtual private gateway

  • An existing virtual * private gateway to a transit gateway

  • An existing transit * gateway to a new transit gateway

  • An existing transit gateway * to a virtual private gateway

Before you perform the migration * to the new gateway, you must configure the new gateway. Use * CreateVpnGateway to create a virtual private gateway, or * CreateTransitGateway to create a transit gateway.

This step is * required when you migrate from a virtual private gateway with static routes to a * transit gateway.

You must delete the static routes before you migrate to * the new gateway.

Keep a copy of the static route before you delete it. * You will need to add back these routes to the transit gateway after the VPN * connection migration is complete.

After you migrate to the new gateway, * you might need to modify your VPC route table. Use CreateRoute and * DeleteRoute to make the changes described in Update * VPC route tables in the Amazon Web Services Site-to-Site VPN User * Guide.

When the new gateway is a transit gateway, modify the transit * gateway route table to allow traffic between the VPC and the Amazon Web Services * Site-to-Site VPN connection. Use CreateTransitGatewayRoute to add the * routes.

If you deleted VPN static routes, you must add the static routes * to the transit gateway route table.

After you perform this operation, the * VPN endpoint's IP addresses on the Amazon Web Services side and the tunnel * options remain intact. Your Amazon Web Services Site-to-Site VPN connection will * be temporarily unavailable for a brief period while we provision the new * endpoints.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpnConnectionOutcome ModifyVpnConnection(const Model::ModifyVpnConnectionRequest& request) const; /** * A Callable wrapper for ModifyVpnConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpnConnectionOutcomeCallable ModifyVpnConnectionCallable(const ModifyVpnConnectionRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpnConnection, request); } /** * An Async wrapper for ModifyVpnConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpnConnectionAsync(const ModifyVpnConnectionRequestT& request, const ModifyVpnConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpnConnection, request, handler, context); } /** *

Modifies the connection options for your Site-to-Site VPN connection.

*

When you modify the VPN connection options, the VPN endpoint IP addresses on * the Amazon Web Services side do not change, and the tunnel options do not * change. Your VPN connection will be temporarily unavailable for a brief period * while the VPN connection is updated.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpnConnectionOptionsOutcome ModifyVpnConnectionOptions(const Model::ModifyVpnConnectionOptionsRequest& request) const; /** * A Callable wrapper for ModifyVpnConnectionOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpnConnectionOptionsOutcomeCallable ModifyVpnConnectionOptionsCallable(const ModifyVpnConnectionOptionsRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpnConnectionOptions, request); } /** * An Async wrapper for ModifyVpnConnectionOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpnConnectionOptionsAsync(const ModifyVpnConnectionOptionsRequestT& request, const ModifyVpnConnectionOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpnConnectionOptions, request, handler, context); } /** *

Modifies the VPN tunnel endpoint certificate.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpnTunnelCertificateOutcome ModifyVpnTunnelCertificate(const Model::ModifyVpnTunnelCertificateRequest& request) const; /** * A Callable wrapper for ModifyVpnTunnelCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpnTunnelCertificateOutcomeCallable ModifyVpnTunnelCertificateCallable(const ModifyVpnTunnelCertificateRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpnTunnelCertificate, request); } /** * An Async wrapper for ModifyVpnTunnelCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpnTunnelCertificateAsync(const ModifyVpnTunnelCertificateRequestT& request, const ModifyVpnTunnelCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpnTunnelCertificate, request, handler, context); } /** *

Modifies the options for a VPN tunnel in an Amazon Web Services Site-to-Site * VPN connection. You can modify multiple options for a tunnel in a single * request, but you can only modify one tunnel at a time. For more information, see * Site-to-Site * VPN tunnel options for your Site-to-Site VPN connection in the Amazon Web * Services Site-to-Site VPN User Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyVpnTunnelOptionsOutcome ModifyVpnTunnelOptions(const Model::ModifyVpnTunnelOptionsRequest& request) const; /** * A Callable wrapper for ModifyVpnTunnelOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyVpnTunnelOptionsOutcomeCallable ModifyVpnTunnelOptionsCallable(const ModifyVpnTunnelOptionsRequestT& request) const { return SubmitCallable(&EC2Client::ModifyVpnTunnelOptions, request); } /** * An Async wrapper for ModifyVpnTunnelOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyVpnTunnelOptionsAsync(const ModifyVpnTunnelOptionsRequestT& request, const ModifyVpnTunnelOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ModifyVpnTunnelOptions, request, handler, context); } /** *

Enables detailed monitoring for a running instance. Otherwise, basic * monitoring is enabled. For more information, see Monitor * your instances using CloudWatch in the Amazon EC2 User Guide.

*

To disable detailed monitoring, see UnmonitorInstances.

See * Also:

AWS * API Reference

*/ virtual Model::MonitorInstancesOutcome MonitorInstances(const Model::MonitorInstancesRequest& request) const; /** * A Callable wrapper for MonitorInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MonitorInstancesOutcomeCallable MonitorInstancesCallable(const MonitorInstancesRequestT& request) const { return SubmitCallable(&EC2Client::MonitorInstances, request); } /** * An Async wrapper for MonitorInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MonitorInstancesAsync(const MonitorInstancesRequestT& request, const MonitorInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::MonitorInstances, request, handler, context); } /** *

This action is deprecated.

Moves an Elastic IP address * from the EC2-Classic platform to the EC2-VPC platform. The Elastic IP address * must be allocated to your account for more than 24 hours, and it must not be * associated with an instance. After the Elastic IP address is moved, it is no * longer available for use in the EC2-Classic platform, unless you move it back * using the RestoreAddressToClassic request. You cannot move an Elastic IP * address that was originally allocated for use in the EC2-VPC platform to the * EC2-Classic platform.

See Also:

AWS * API Reference

*/ virtual Model::MoveAddressToVpcOutcome MoveAddressToVpc(const Model::MoveAddressToVpcRequest& request) const; /** * A Callable wrapper for MoveAddressToVpc that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MoveAddressToVpcOutcomeCallable MoveAddressToVpcCallable(const MoveAddressToVpcRequestT& request) const { return SubmitCallable(&EC2Client::MoveAddressToVpc, request); } /** * An Async wrapper for MoveAddressToVpc that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MoveAddressToVpcAsync(const MoveAddressToVpcRequestT& request, const MoveAddressToVpcResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::MoveAddressToVpc, request, handler, context); } /** *

Move a BYOIPv4 CIDR to IPAM from a public IPv4 pool.

If you already * have a BYOIPv4 CIDR with Amazon Web Services, you can move the CIDR to IPAM from * a public IPv4 pool. You cannot move an IPv6 CIDR to IPAM. If you are bringing a * new IP address to Amazon Web Services for the first time, complete the steps in * Tutorial: * BYOIP address CIDRs to IPAM.

See Also:

AWS * API Reference

*/ virtual Model::MoveByoipCidrToIpamOutcome MoveByoipCidrToIpam(const Model::MoveByoipCidrToIpamRequest& request) const; /** * A Callable wrapper for MoveByoipCidrToIpam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MoveByoipCidrToIpamOutcomeCallable MoveByoipCidrToIpamCallable(const MoveByoipCidrToIpamRequestT& request) const { return SubmitCallable(&EC2Client::MoveByoipCidrToIpam, request); } /** * An Async wrapper for MoveByoipCidrToIpam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MoveByoipCidrToIpamAsync(const MoveByoipCidrToIpamRequestT& request, const MoveByoipCidrToIpamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::MoveByoipCidrToIpam, request, handler, context); } /** *

Provisions an IPv4 or IPv6 address range for use with your Amazon Web * Services resources through bring your own IP addresses (BYOIP) and creates a * corresponding address pool. After the address range is provisioned, it is ready * to be advertised using AdvertiseByoipCidr.

Amazon Web Services * verifies that you own the address range and are authorized to advertise it. You * must ensure that the address range is registered to you and that you created an * RPKI ROA to authorize Amazon ASNs 16509 and 14618 to advertise the address * range. For more information, see Bring * your own IP addresses (BYOIP) in the Amazon Elastic Compute Cloud User * Guide.

Provisioning an address range is an asynchronous operation, so * the call returns immediately, but the address range is not ready to use until * its status changes from pending-provision to * provisioned. To monitor the status of an address range, use * DescribeByoipCidrs. To allocate an Elastic IP address from your IPv4 * address pool, use AllocateAddress with either the specific address from * the address pool or the ID of the address pool.

See Also:

AWS * API Reference

*/ virtual Model::ProvisionByoipCidrOutcome ProvisionByoipCidr(const Model::ProvisionByoipCidrRequest& request) const; /** * A Callable wrapper for ProvisionByoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ProvisionByoipCidrOutcomeCallable ProvisionByoipCidrCallable(const ProvisionByoipCidrRequestT& request) const { return SubmitCallable(&EC2Client::ProvisionByoipCidr, request); } /** * An Async wrapper for ProvisionByoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ProvisionByoipCidrAsync(const ProvisionByoipCidrRequestT& request, const ProvisionByoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ProvisionByoipCidr, request, handler, context); } /** *

Provision a CIDR to an IPAM pool. You can use this action to provision new * CIDRs to a top-level pool or to transfer a CIDR from a top-level pool to a pool * within it.

For more information, see Provision * CIDRs to pools in the Amazon VPC IPAM User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ProvisionIpamPoolCidrOutcome ProvisionIpamPoolCidr(const Model::ProvisionIpamPoolCidrRequest& request) const; /** * A Callable wrapper for ProvisionIpamPoolCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ProvisionIpamPoolCidrOutcomeCallable ProvisionIpamPoolCidrCallable(const ProvisionIpamPoolCidrRequestT& request) const { return SubmitCallable(&EC2Client::ProvisionIpamPoolCidr, request); } /** * An Async wrapper for ProvisionIpamPoolCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ProvisionIpamPoolCidrAsync(const ProvisionIpamPoolCidrRequestT& request, const ProvisionIpamPoolCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ProvisionIpamPoolCidr, request, handler, context); } /** *

Provision a CIDR to a public IPv4 pool.

For more information about * IPAM, see What is * IPAM? in the Amazon VPC IPAM User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::ProvisionPublicIpv4PoolCidrOutcome ProvisionPublicIpv4PoolCidr(const Model::ProvisionPublicIpv4PoolCidrRequest& request) const; /** * A Callable wrapper for ProvisionPublicIpv4PoolCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ProvisionPublicIpv4PoolCidrOutcomeCallable ProvisionPublicIpv4PoolCidrCallable(const ProvisionPublicIpv4PoolCidrRequestT& request) const { return SubmitCallable(&EC2Client::ProvisionPublicIpv4PoolCidr, request); } /** * An Async wrapper for ProvisionPublicIpv4PoolCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ProvisionPublicIpv4PoolCidrAsync(const ProvisionPublicIpv4PoolCidrRequestT& request, const ProvisionPublicIpv4PoolCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ProvisionPublicIpv4PoolCidr, request, handler, context); } /** *

Purchase a reservation with configurations that match those of your Dedicated * Host. You must have active Dedicated Hosts in your account before you purchase a * reservation. This action results in the specified reservation being purchased * and charged to your account.

See Also:

AWS * API Reference

*/ virtual Model::PurchaseHostReservationOutcome PurchaseHostReservation(const Model::PurchaseHostReservationRequest& request) const; /** * A Callable wrapper for PurchaseHostReservation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PurchaseHostReservationOutcomeCallable PurchaseHostReservationCallable(const PurchaseHostReservationRequestT& request) const { return SubmitCallable(&EC2Client::PurchaseHostReservation, request); } /** * An Async wrapper for PurchaseHostReservation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PurchaseHostReservationAsync(const PurchaseHostReservationRequestT& request, const PurchaseHostReservationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::PurchaseHostReservation, request, handler, context); } /** *

Purchases a Reserved Instance for use with your account. With Reserved * Instances, you pay a lower hourly rate compared to On-Demand instance * pricing.

Use DescribeReservedInstancesOfferings to get a list of * Reserved Instance offerings that match your specifications. After you've * purchased a Reserved Instance, you can check for your new Reserved Instance with * DescribeReservedInstances.

To queue a purchase for a future date * and time, specify a purchase time. If you do not specify a purchase time, the * default is the current time.

For more information, see Reserved * Instances and Reserved * Instance Marketplace in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::PurchaseReservedInstancesOfferingOutcome PurchaseReservedInstancesOffering(const Model::PurchaseReservedInstancesOfferingRequest& request) const; /** * A Callable wrapper for PurchaseReservedInstancesOffering that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PurchaseReservedInstancesOfferingOutcomeCallable PurchaseReservedInstancesOfferingCallable(const PurchaseReservedInstancesOfferingRequestT& request) const { return SubmitCallable(&EC2Client::PurchaseReservedInstancesOffering, request); } /** * An Async wrapper for PurchaseReservedInstancesOffering that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PurchaseReservedInstancesOfferingAsync(const PurchaseReservedInstancesOfferingRequestT& request, const PurchaseReservedInstancesOfferingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::PurchaseReservedInstancesOffering, request, handler, context); } /** *

You can no longer purchase Scheduled Instances.

*

Purchases the Scheduled Instances with the specified schedule.

*

Scheduled Instances enable you to purchase Amazon EC2 compute capacity by the * hour for a one-year term. Before you can purchase a Scheduled Instance, you must * call DescribeScheduledInstanceAvailability to check for available * schedules and obtain a purchase token. After you purchase a Scheduled Instance, * you must call RunScheduledInstances during each scheduled time * period.

After you purchase a Scheduled Instance, you can't cancel, * modify, or resell your purchase.

See Also:

AWS * API Reference

*/ virtual Model::PurchaseScheduledInstancesOutcome PurchaseScheduledInstances(const Model::PurchaseScheduledInstancesRequest& request) const; /** * A Callable wrapper for PurchaseScheduledInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PurchaseScheduledInstancesOutcomeCallable PurchaseScheduledInstancesCallable(const PurchaseScheduledInstancesRequestT& request) const { return SubmitCallable(&EC2Client::PurchaseScheduledInstances, request); } /** * An Async wrapper for PurchaseScheduledInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PurchaseScheduledInstancesAsync(const PurchaseScheduledInstancesRequestT& request, const PurchaseScheduledInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::PurchaseScheduledInstances, request, handler, context); } /** *

Requests a reboot of the specified instances. This operation is asynchronous; * it only queues a request to reboot the specified instances. The operation * succeeds if the instances are valid and belong to you. Requests to reboot * terminated instances are ignored.

If an instance does not cleanly shut * down within a few minutes, Amazon EC2 performs a hard reboot.

For more * information about troubleshooting, see Troubleshoot * an unreachable instance in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::RebootInstancesOutcome RebootInstances(const Model::RebootInstancesRequest& request) const; /** * A Callable wrapper for RebootInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebootInstancesOutcomeCallable RebootInstancesCallable(const RebootInstancesRequestT& request) const { return SubmitCallable(&EC2Client::RebootInstances, request); } /** * An Async wrapper for RebootInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebootInstancesAsync(const RebootInstancesRequestT& request, const RebootInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RebootInstances, request, handler, context); } /** *

Registers an AMI. When you're creating an AMI, this is the final step you * must complete before you can launch an instance from the AMI. For more * information about creating AMIs, see Create * your own AMI in the Amazon Elastic Compute Cloud User Guide.

*

For Amazon EBS-backed instances, CreateImage creates and * registers the AMI in a single request, so you don't have to register the AMI * yourself. We recommend that you always use CreateImage unless you have a * specific reason to use RegisterImage.

If needed, you can * deregister an AMI at any time. Any modifications you make to an AMI backed by an * instance store volume invalidates its registration. If you make changes to an * image, deregister the previous image and register the new image.

* Register a snapshot of a root device volume

You can use * RegisterImage to create an Amazon EBS-backed Linux AMI from a * snapshot of a root device volume. You specify the snapshot using a block device * mapping. You can't set the encryption state of the volume using the block device * mapping. If the snapshot is encrypted, or encryption by default is enabled, the * root volume of an instance launched from the AMI is encrypted.

For more * information, see Create * a Linux AMI from a snapshot and Use * encryption with Amazon EBS-backed AMIs in the Amazon Elastic Compute * Cloud User Guide.

Amazon Web Services Marketplace product * codes

If any snapshots have Amazon Web Services Marketplace product * codes, they are copied to the new AMI.

Windows and some Linux * distributions, such as Red Hat Enterprise Linux (RHEL) and SUSE Linux Enterprise * Server (SLES), use the Amazon EC2 billing product code associated with an AMI to * verify the subscription status for package updates. To create a new AMI for * operating systems that require a billing product code, instead of registering * the AMI, do the following to preserve the billing product code association:

*

  1. Launch an instance from an existing AMI with that billing product * code.

  2. Customize the instance.

  3. Create an AMI * from the instance using CreateImage.

If you purchase a * Reserved Instance to apply to an On-Demand Instance that was launched from an * AMI with a billing product code, make sure that the Reserved Instance has the * matching billing product code. If you purchase a Reserved Instance without the * matching billing product code, the Reserved Instance will not be applied to the * On-Demand Instance. For information about how to obtain the platform details and * billing information of an AMI, see Understand * AMI billing information in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::RegisterImageOutcome RegisterImage(const Model::RegisterImageRequest& request) const; /** * A Callable wrapper for RegisterImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterImageOutcomeCallable RegisterImageCallable(const RegisterImageRequestT& request) const { return SubmitCallable(&EC2Client::RegisterImage, request); } /** * An Async wrapper for RegisterImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterImageAsync(const RegisterImageRequestT& request, const RegisterImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RegisterImage, request, handler, context); } /** *

Registers a set of tag keys to include in scheduled event notifications for * your resources.

To remove tags, use DeregisterInstanceEventNotificationAttributes.

See * Also:

AWS * API Reference

*/ virtual Model::RegisterInstanceEventNotificationAttributesOutcome RegisterInstanceEventNotificationAttributes(const Model::RegisterInstanceEventNotificationAttributesRequest& request) const; /** * A Callable wrapper for RegisterInstanceEventNotificationAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterInstanceEventNotificationAttributesOutcomeCallable RegisterInstanceEventNotificationAttributesCallable(const RegisterInstanceEventNotificationAttributesRequestT& request) const { return SubmitCallable(&EC2Client::RegisterInstanceEventNotificationAttributes, request); } /** * An Async wrapper for RegisterInstanceEventNotificationAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterInstanceEventNotificationAttributesAsync(const RegisterInstanceEventNotificationAttributesRequestT& request, const RegisterInstanceEventNotificationAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RegisterInstanceEventNotificationAttributes, request, handler, context); } /** *

Registers members (network interfaces) with the transit gateway multicast * group. A member is a network interface associated with a supported EC2 instance * that receives multicast traffic. For information about supported instances, see * Multicast * Consideration in Amazon VPC Transit Gateways.

After you add * the members, use SearchTransitGatewayMulticastGroups * to verify that the members were added to the transit gateway multicast * group.

See Also:

AWS * API Reference

*/ virtual Model::RegisterTransitGatewayMulticastGroupMembersOutcome RegisterTransitGatewayMulticastGroupMembers(const Model::RegisterTransitGatewayMulticastGroupMembersRequest& request) const; /** * A Callable wrapper for RegisterTransitGatewayMulticastGroupMembers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterTransitGatewayMulticastGroupMembersOutcomeCallable RegisterTransitGatewayMulticastGroupMembersCallable(const RegisterTransitGatewayMulticastGroupMembersRequestT& request) const { return SubmitCallable(&EC2Client::RegisterTransitGatewayMulticastGroupMembers, request); } /** * An Async wrapper for RegisterTransitGatewayMulticastGroupMembers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterTransitGatewayMulticastGroupMembersAsync(const RegisterTransitGatewayMulticastGroupMembersRequestT& request, const RegisterTransitGatewayMulticastGroupMembersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RegisterTransitGatewayMulticastGroupMembers, request, handler, context); } /** *

Registers sources (network interfaces) with the specified transit gateway * multicast group.

A multicast source is a network interface attached to a * supported instance that sends multicast traffic. For information about supported * instances, see Multicast * Considerations in Amazon VPC Transit Gateways.

After you add * the source, use SearchTransitGatewayMulticastGroups * to verify that the source was added to the multicast group.

See * Also:

AWS * API Reference

*/ virtual Model::RegisterTransitGatewayMulticastGroupSourcesOutcome RegisterTransitGatewayMulticastGroupSources(const Model::RegisterTransitGatewayMulticastGroupSourcesRequest& request) const; /** * A Callable wrapper for RegisterTransitGatewayMulticastGroupSources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterTransitGatewayMulticastGroupSourcesOutcomeCallable RegisterTransitGatewayMulticastGroupSourcesCallable(const RegisterTransitGatewayMulticastGroupSourcesRequestT& request) const { return SubmitCallable(&EC2Client::RegisterTransitGatewayMulticastGroupSources, request); } /** * An Async wrapper for RegisterTransitGatewayMulticastGroupSources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterTransitGatewayMulticastGroupSourcesAsync(const RegisterTransitGatewayMulticastGroupSourcesRequestT& request, const RegisterTransitGatewayMulticastGroupSourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RegisterTransitGatewayMulticastGroupSources, request, handler, context); } /** *

Rejects a request to associate cross-account subnets with a transit gateway * multicast domain.

See Also:

AWS * API Reference

*/ virtual Model::RejectTransitGatewayMulticastDomainAssociationsOutcome RejectTransitGatewayMulticastDomainAssociations(const Model::RejectTransitGatewayMulticastDomainAssociationsRequest& request) const; /** * A Callable wrapper for RejectTransitGatewayMulticastDomainAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RejectTransitGatewayMulticastDomainAssociationsOutcomeCallable RejectTransitGatewayMulticastDomainAssociationsCallable(const RejectTransitGatewayMulticastDomainAssociationsRequestT& request) const { return SubmitCallable(&EC2Client::RejectTransitGatewayMulticastDomainAssociations, request); } /** * An Async wrapper for RejectTransitGatewayMulticastDomainAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RejectTransitGatewayMulticastDomainAssociationsAsync(const RejectTransitGatewayMulticastDomainAssociationsRequestT& request, const RejectTransitGatewayMulticastDomainAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RejectTransitGatewayMulticastDomainAssociations, request, handler, context); } /** *

Rejects a transit gateway peering attachment request.

See * Also:

AWS * API Reference

*/ virtual Model::RejectTransitGatewayPeeringAttachmentOutcome RejectTransitGatewayPeeringAttachment(const Model::RejectTransitGatewayPeeringAttachmentRequest& request) const; /** * A Callable wrapper for RejectTransitGatewayPeeringAttachment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RejectTransitGatewayPeeringAttachmentOutcomeCallable RejectTransitGatewayPeeringAttachmentCallable(const RejectTransitGatewayPeeringAttachmentRequestT& request) const { return SubmitCallable(&EC2Client::RejectTransitGatewayPeeringAttachment, request); } /** * An Async wrapper for RejectTransitGatewayPeeringAttachment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RejectTransitGatewayPeeringAttachmentAsync(const RejectTransitGatewayPeeringAttachmentRequestT& request, const RejectTransitGatewayPeeringAttachmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RejectTransitGatewayPeeringAttachment, request, handler, context); } /** *

Rejects a request to attach a VPC to a transit gateway.

The VPC * attachment must be in the pendingAcceptance state. Use * DescribeTransitGatewayVpcAttachments to view your pending VPC attachment * requests. Use AcceptTransitGatewayVpcAttachment to accept a VPC * attachment request.

See Also:

AWS * API Reference

*/ virtual Model::RejectTransitGatewayVpcAttachmentOutcome RejectTransitGatewayVpcAttachment(const Model::RejectTransitGatewayVpcAttachmentRequest& request) const; /** * A Callable wrapper for RejectTransitGatewayVpcAttachment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RejectTransitGatewayVpcAttachmentOutcomeCallable RejectTransitGatewayVpcAttachmentCallable(const RejectTransitGatewayVpcAttachmentRequestT& request) const { return SubmitCallable(&EC2Client::RejectTransitGatewayVpcAttachment, request); } /** * An Async wrapper for RejectTransitGatewayVpcAttachment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RejectTransitGatewayVpcAttachmentAsync(const RejectTransitGatewayVpcAttachmentRequestT& request, const RejectTransitGatewayVpcAttachmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RejectTransitGatewayVpcAttachment, request, handler, context); } /** *

Rejects VPC endpoint connection requests to your VPC endpoint * service.

See Also:

AWS * API Reference

*/ virtual Model::RejectVpcEndpointConnectionsOutcome RejectVpcEndpointConnections(const Model::RejectVpcEndpointConnectionsRequest& request) const; /** * A Callable wrapper for RejectVpcEndpointConnections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RejectVpcEndpointConnectionsOutcomeCallable RejectVpcEndpointConnectionsCallable(const RejectVpcEndpointConnectionsRequestT& request) const { return SubmitCallable(&EC2Client::RejectVpcEndpointConnections, request); } /** * An Async wrapper for RejectVpcEndpointConnections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RejectVpcEndpointConnectionsAsync(const RejectVpcEndpointConnectionsRequestT& request, const RejectVpcEndpointConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RejectVpcEndpointConnections, request, handler, context); } /** *

Rejects a VPC peering connection request. The VPC peering connection must be * in the pending-acceptance state. Use the * DescribeVpcPeeringConnections request to view your outstanding VPC * peering connection requests. To delete an active VPC peering connection, or to * delete a VPC peering connection request that you initiated, use * DeleteVpcPeeringConnection.

See Also:

AWS * API Reference

*/ virtual Model::RejectVpcPeeringConnectionOutcome RejectVpcPeeringConnection(const Model::RejectVpcPeeringConnectionRequest& request) const; /** * A Callable wrapper for RejectVpcPeeringConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RejectVpcPeeringConnectionOutcomeCallable RejectVpcPeeringConnectionCallable(const RejectVpcPeeringConnectionRequestT& request) const { return SubmitCallable(&EC2Client::RejectVpcPeeringConnection, request); } /** * An Async wrapper for RejectVpcPeeringConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RejectVpcPeeringConnectionAsync(const RejectVpcPeeringConnectionRequestT& request, const RejectVpcPeeringConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RejectVpcPeeringConnection, request, handler, context); } /** *

Releases the specified Elastic IP address.

[Default VPC] Releasing an * Elastic IP address automatically disassociates it from any instance that it's * associated with. To disassociate an Elastic IP address without releasing it, use * DisassociateAddress.

[Nondefault VPC] You must use * DisassociateAddress to disassociate the Elastic IP address before you can * release it. Otherwise, Amazon EC2 returns an error * (InvalidIPAddress.InUse).

After releasing an Elastic IP * address, it is released to the IP address pool. Be sure to update your DNS * records and any servers or devices that communicate with the address. If you * attempt to release an Elastic IP address that you already released, you'll get * an AuthFailure error if the address is already allocated to another * Amazon Web Services account.

After you release an Elastic IP address, you * might be able to recover it. For more information, see * AllocateAddress.

See Also:

AWS * API Reference

*/ virtual Model::ReleaseAddressOutcome ReleaseAddress(const Model::ReleaseAddressRequest& request) const; /** * A Callable wrapper for ReleaseAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReleaseAddressOutcomeCallable ReleaseAddressCallable(const ReleaseAddressRequestT& request) const { return SubmitCallable(&EC2Client::ReleaseAddress, request); } /** * An Async wrapper for ReleaseAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReleaseAddressAsync(const ReleaseAddressRequestT& request, const ReleaseAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReleaseAddress, request, handler, context); } /** *

When you no longer want to use an On-Demand Dedicated Host it can be * released. On-Demand billing is stopped and the host goes into * released state. The host ID of Dedicated Hosts that have been * released can no longer be specified in another request, for example, to modify * the host. You must stop or terminate all instances on a host before it can be * released.

When Dedicated Hosts are released, it may take some time for * them to stop counting toward your limit and you may receive capacity errors when * trying to allocate new Dedicated Hosts. Wait a few minutes and then try * again.

Released hosts still appear in a DescribeHosts * response.

See Also:

AWS * API Reference

*/ virtual Model::ReleaseHostsOutcome ReleaseHosts(const Model::ReleaseHostsRequest& request) const; /** * A Callable wrapper for ReleaseHosts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReleaseHostsOutcomeCallable ReleaseHostsCallable(const ReleaseHostsRequestT& request) const { return SubmitCallable(&EC2Client::ReleaseHosts, request); } /** * An Async wrapper for ReleaseHosts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReleaseHostsAsync(const ReleaseHostsRequestT& request, const ReleaseHostsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReleaseHosts, request, handler, context); } /** *

Release an allocation within an IPAM pool. The Region you use should be the * IPAM pool locale. The locale is the Amazon Web Services Region where this IPAM * pool is available for allocations. You can only use this action to release * manual allocations. To remove an allocation for a resource without deleting the * resource, set its monitored state to false using ModifyIpamResourceCidr. * For more information, see Release * an allocation in the Amazon VPC IPAM User Guide.

All * EC2 API actions follow an eventual * consistency model.

See Also:

AWS * API Reference

*/ virtual Model::ReleaseIpamPoolAllocationOutcome ReleaseIpamPoolAllocation(const Model::ReleaseIpamPoolAllocationRequest& request) const; /** * A Callable wrapper for ReleaseIpamPoolAllocation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReleaseIpamPoolAllocationOutcomeCallable ReleaseIpamPoolAllocationCallable(const ReleaseIpamPoolAllocationRequestT& request) const { return SubmitCallable(&EC2Client::ReleaseIpamPoolAllocation, request); } /** * An Async wrapper for ReleaseIpamPoolAllocation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReleaseIpamPoolAllocationAsync(const ReleaseIpamPoolAllocationRequestT& request, const ReleaseIpamPoolAllocationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReleaseIpamPoolAllocation, request, handler, context); } /** *

Replaces an IAM instance profile for the specified running instance. You can * use this action to change the IAM instance profile that's associated with an * instance without having to disassociate the existing IAM instance profile * first.

Use DescribeIamInstanceProfileAssociations to get the * association ID.

See Also:

AWS * API Reference

*/ virtual Model::ReplaceIamInstanceProfileAssociationOutcome ReplaceIamInstanceProfileAssociation(const Model::ReplaceIamInstanceProfileAssociationRequest& request) const; /** * A Callable wrapper for ReplaceIamInstanceProfileAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReplaceIamInstanceProfileAssociationOutcomeCallable ReplaceIamInstanceProfileAssociationCallable(const ReplaceIamInstanceProfileAssociationRequestT& request) const { return SubmitCallable(&EC2Client::ReplaceIamInstanceProfileAssociation, request); } /** * An Async wrapper for ReplaceIamInstanceProfileAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReplaceIamInstanceProfileAssociationAsync(const ReplaceIamInstanceProfileAssociationRequestT& request, const ReplaceIamInstanceProfileAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReplaceIamInstanceProfileAssociation, request, handler, context); } /** *

Changes which network ACL a subnet is associated with. By default when you * create a subnet, it's automatically associated with the default network ACL. For * more information, see Network * ACLs in the Amazon VPC User Guide.

This is an idempotent * operation.

See Also:

AWS * API Reference

*/ virtual Model::ReplaceNetworkAclAssociationOutcome ReplaceNetworkAclAssociation(const Model::ReplaceNetworkAclAssociationRequest& request) const; /** * A Callable wrapper for ReplaceNetworkAclAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReplaceNetworkAclAssociationOutcomeCallable ReplaceNetworkAclAssociationCallable(const ReplaceNetworkAclAssociationRequestT& request) const { return SubmitCallable(&EC2Client::ReplaceNetworkAclAssociation, request); } /** * An Async wrapper for ReplaceNetworkAclAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReplaceNetworkAclAssociationAsync(const ReplaceNetworkAclAssociationRequestT& request, const ReplaceNetworkAclAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReplaceNetworkAclAssociation, request, handler, context); } /** *

Replaces an entry (rule) in a network ACL. For more information, see Network * ACLs in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::ReplaceNetworkAclEntryOutcome ReplaceNetworkAclEntry(const Model::ReplaceNetworkAclEntryRequest& request) const; /** * A Callable wrapper for ReplaceNetworkAclEntry that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReplaceNetworkAclEntryOutcomeCallable ReplaceNetworkAclEntryCallable(const ReplaceNetworkAclEntryRequestT& request) const { return SubmitCallable(&EC2Client::ReplaceNetworkAclEntry, request); } /** * An Async wrapper for ReplaceNetworkAclEntry that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReplaceNetworkAclEntryAsync(const ReplaceNetworkAclEntryRequestT& request, const ReplaceNetworkAclEntryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReplaceNetworkAclEntry, request, handler, context); } /** *

Replaces an existing route within a route table in a VPC.

You must * specify either a destination CIDR block or a prefix list ID. You must also * specify exactly one of the resources from the parameter list, or reset the local * route to its default target.

For more information, see Route * tables in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::ReplaceRouteOutcome ReplaceRoute(const Model::ReplaceRouteRequest& request) const; /** * A Callable wrapper for ReplaceRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReplaceRouteOutcomeCallable ReplaceRouteCallable(const ReplaceRouteRequestT& request) const { return SubmitCallable(&EC2Client::ReplaceRoute, request); } /** * An Async wrapper for ReplaceRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReplaceRouteAsync(const ReplaceRouteRequestT& request, const ReplaceRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReplaceRoute, request, handler, context); } /** *

Changes the route table associated with a given subnet, internet gateway, or * virtual private gateway in a VPC. After the operation completes, the subnet or * gateway uses the routes in the new route table. For more information about route * tables, see Route * tables in the Amazon VPC User Guide.

You can also use this * operation to change which table is the main route table in the VPC. Specify the * main route table's association ID and the route table ID of the new main route * table.

See Also:

AWS * API Reference

*/ virtual Model::ReplaceRouteTableAssociationOutcome ReplaceRouteTableAssociation(const Model::ReplaceRouteTableAssociationRequest& request) const; /** * A Callable wrapper for ReplaceRouteTableAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReplaceRouteTableAssociationOutcomeCallable ReplaceRouteTableAssociationCallable(const ReplaceRouteTableAssociationRequestT& request) const { return SubmitCallable(&EC2Client::ReplaceRouteTableAssociation, request); } /** * An Async wrapper for ReplaceRouteTableAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReplaceRouteTableAssociationAsync(const ReplaceRouteTableAssociationRequestT& request, const ReplaceRouteTableAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReplaceRouteTableAssociation, request, handler, context); } /** *

Replaces the specified route in the specified transit gateway route * table.

See Also:

AWS * API Reference

*/ virtual Model::ReplaceTransitGatewayRouteOutcome ReplaceTransitGatewayRoute(const Model::ReplaceTransitGatewayRouteRequest& request) const; /** * A Callable wrapper for ReplaceTransitGatewayRoute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReplaceTransitGatewayRouteOutcomeCallable ReplaceTransitGatewayRouteCallable(const ReplaceTransitGatewayRouteRequestT& request) const { return SubmitCallable(&EC2Client::ReplaceTransitGatewayRoute, request); } /** * An Async wrapper for ReplaceTransitGatewayRoute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReplaceTransitGatewayRouteAsync(const ReplaceTransitGatewayRouteRequestT& request, const ReplaceTransitGatewayRouteResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReplaceTransitGatewayRoute, request, handler, context); } /** *

Trigger replacement of specified VPN tunnel.

See Also:

AWS * API Reference

*/ virtual Model::ReplaceVpnTunnelOutcome ReplaceVpnTunnel(const Model::ReplaceVpnTunnelRequest& request) const; /** * A Callable wrapper for ReplaceVpnTunnel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReplaceVpnTunnelOutcomeCallable ReplaceVpnTunnelCallable(const ReplaceVpnTunnelRequestT& request) const { return SubmitCallable(&EC2Client::ReplaceVpnTunnel, request); } /** * An Async wrapper for ReplaceVpnTunnel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReplaceVpnTunnelAsync(const ReplaceVpnTunnelRequestT& request, const ReplaceVpnTunnelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReplaceVpnTunnel, request, handler, context); } /** *

Submits feedback about the status of an instance. The instance must be in the * running state. If your experience with the instance differs from * the instance status returned by DescribeInstanceStatus, use * ReportInstanceStatus to report your experience with the instance. Amazon * EC2 collects this information to improve the accuracy of status checks.

*

Use of this action does not change the value returned by * DescribeInstanceStatus.

See Also:

AWS * API Reference

*/ virtual Model::ReportInstanceStatusOutcome ReportInstanceStatus(const Model::ReportInstanceStatusRequest& request) const; /** * A Callable wrapper for ReportInstanceStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReportInstanceStatusOutcomeCallable ReportInstanceStatusCallable(const ReportInstanceStatusRequestT& request) const { return SubmitCallable(&EC2Client::ReportInstanceStatus, request); } /** * An Async wrapper for ReportInstanceStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReportInstanceStatusAsync(const ReportInstanceStatusRequestT& request, const ReportInstanceStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ReportInstanceStatus, request, handler, context); } /** *

Creates a Spot Fleet request.

The Spot Fleet request specifies the * total target capacity and the On-Demand target capacity. Amazon EC2 calculates * the difference between the total capacity and On-Demand capacity, and launches * the difference as Spot capacity.

You can submit a single request that * includes multiple launch specifications that vary by instance type, AMI, * Availability Zone, or subnet.

By default, the Spot Fleet requests Spot * Instances in the Spot Instance pool where the price per unit is the lowest. Each * launch specification can include its own instance weighting that reflects the * value of the instance type to your application workload.

Alternatively, * you can specify that the Spot Fleet distribute the target capacity across the * Spot pools included in its launch specifications. By ensuring that the Spot * Instances in your Spot Fleet are in different Spot pools, you can improve the * availability of your fleet.

You can specify tags for the Spot Fleet * request and instances launched by the fleet. You cannot tag other resource types * in a Spot Fleet request because only the spot-fleet-request and * instance resource types are supported.

For more information, * see Spot * Fleet requests in the Amazon EC2 User Guide.

We * strongly discourage using the RequestSpotFleet API because it is a legacy API * with no planned investment. For options for requesting Spot Instances, see Which * is the best Spot request method to use? in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::RequestSpotFleetOutcome RequestSpotFleet(const Model::RequestSpotFleetRequest& request) const; /** * A Callable wrapper for RequestSpotFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RequestSpotFleetOutcomeCallable RequestSpotFleetCallable(const RequestSpotFleetRequestT& request) const { return SubmitCallable(&EC2Client::RequestSpotFleet, request); } /** * An Async wrapper for RequestSpotFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RequestSpotFleetAsync(const RequestSpotFleetRequestT& request, const RequestSpotFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RequestSpotFleet, request, handler, context); } /** *

Creates a Spot Instance request.

For more information, see Spot * Instance requests in the Amazon EC2 User Guide for Linux * Instances.

We strongly discourage using the * RequestSpotInstances API because it is a legacy API with no planned investment. * For options for requesting Spot Instances, see Which * is the best Spot request method to use? in the Amazon EC2 User Guide for * Linux Instances.

See Also:

AWS * API Reference

*/ virtual Model::RequestSpotInstancesOutcome RequestSpotInstances(const Model::RequestSpotInstancesRequest& request) const; /** * A Callable wrapper for RequestSpotInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RequestSpotInstancesOutcomeCallable RequestSpotInstancesCallable(const RequestSpotInstancesRequestT& request) const { return SubmitCallable(&EC2Client::RequestSpotInstances, request); } /** * An Async wrapper for RequestSpotInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RequestSpotInstancesAsync(const RequestSpotInstancesRequestT& request, const RequestSpotInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RequestSpotInstances, request, handler, context); } /** *

Resets the attribute of the specified IP address. For requirements, see Using * reverse DNS for email applications.

See Also:

AWS * API Reference

*/ virtual Model::ResetAddressAttributeOutcome ResetAddressAttribute(const Model::ResetAddressAttributeRequest& request) const; /** * A Callable wrapper for ResetAddressAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetAddressAttributeOutcomeCallable ResetAddressAttributeCallable(const ResetAddressAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ResetAddressAttribute, request); } /** * An Async wrapper for ResetAddressAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetAddressAttributeAsync(const ResetAddressAttributeRequestT& request, const ResetAddressAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ResetAddressAttribute, request, handler, context); } /** *

Resets the default KMS key for EBS encryption for your account in this Region * to the Amazon Web Services managed KMS key for EBS.

After resetting the * default KMS key to the Amazon Web Services managed KMS key, you can continue to * encrypt by a customer managed KMS key by specifying it when you create the * volume. For more information, see Amazon * EBS encryption in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ResetEbsDefaultKmsKeyIdOutcome ResetEbsDefaultKmsKeyId(const Model::ResetEbsDefaultKmsKeyIdRequest& request) const; /** * A Callable wrapper for ResetEbsDefaultKmsKeyId that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetEbsDefaultKmsKeyIdOutcomeCallable ResetEbsDefaultKmsKeyIdCallable(const ResetEbsDefaultKmsKeyIdRequestT& request) const { return SubmitCallable(&EC2Client::ResetEbsDefaultKmsKeyId, request); } /** * An Async wrapper for ResetEbsDefaultKmsKeyId that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetEbsDefaultKmsKeyIdAsync(const ResetEbsDefaultKmsKeyIdRequestT& request, const ResetEbsDefaultKmsKeyIdResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ResetEbsDefaultKmsKeyId, request, handler, context); } /** *

Resets the specified attribute of the specified Amazon FPGA Image (AFI) to * its default value. You can only reset the load permission * attribute.

See Also:

AWS * API Reference

*/ virtual Model::ResetFpgaImageAttributeOutcome ResetFpgaImageAttribute(const Model::ResetFpgaImageAttributeRequest& request) const; /** * A Callable wrapper for ResetFpgaImageAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetFpgaImageAttributeOutcomeCallable ResetFpgaImageAttributeCallable(const ResetFpgaImageAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ResetFpgaImageAttribute, request); } /** * An Async wrapper for ResetFpgaImageAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetFpgaImageAttributeAsync(const ResetFpgaImageAttributeRequestT& request, const ResetFpgaImageAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ResetFpgaImageAttribute, request, handler, context); } /** *

Resets an attribute of an AMI to its default value.

See Also:

* AWS * API Reference

*/ virtual Model::ResetImageAttributeOutcome ResetImageAttribute(const Model::ResetImageAttributeRequest& request) const; /** * A Callable wrapper for ResetImageAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetImageAttributeOutcomeCallable ResetImageAttributeCallable(const ResetImageAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ResetImageAttribute, request); } /** * An Async wrapper for ResetImageAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetImageAttributeAsync(const ResetImageAttributeRequestT& request, const ResetImageAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ResetImageAttribute, request, handler, context); } /** *

Resets an attribute of an instance to its default value. To reset the * kernel or ramdisk, the instance must be in a stopped * state. To reset the sourceDestCheck, the instance can be either * running or stopped.

The sourceDestCheck attribute controls * whether source/destination checking is enabled. The default value is * true, which means checking is enabled. This value must be * false for a NAT instance to perform NAT. For more information, see * NAT * Instances in the Amazon VPC User Guide.

See Also:

AWS * API Reference

*/ virtual Model::ResetInstanceAttributeOutcome ResetInstanceAttribute(const Model::ResetInstanceAttributeRequest& request) const; /** * A Callable wrapper for ResetInstanceAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetInstanceAttributeOutcomeCallable ResetInstanceAttributeCallable(const ResetInstanceAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ResetInstanceAttribute, request); } /** * An Async wrapper for ResetInstanceAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetInstanceAttributeAsync(const ResetInstanceAttributeRequestT& request, const ResetInstanceAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ResetInstanceAttribute, request, handler, context); } /** *

Resets a network interface attribute. You can specify only one attribute at a * time.

See Also:

AWS * API Reference

*/ virtual Model::ResetNetworkInterfaceAttributeOutcome ResetNetworkInterfaceAttribute(const Model::ResetNetworkInterfaceAttributeRequest& request) const; /** * A Callable wrapper for ResetNetworkInterfaceAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetNetworkInterfaceAttributeOutcomeCallable ResetNetworkInterfaceAttributeCallable(const ResetNetworkInterfaceAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ResetNetworkInterfaceAttribute, request); } /** * An Async wrapper for ResetNetworkInterfaceAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetNetworkInterfaceAttributeAsync(const ResetNetworkInterfaceAttributeRequestT& request, const ResetNetworkInterfaceAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ResetNetworkInterfaceAttribute, request, handler, context); } /** *

Resets permission settings for the specified snapshot.

For more * information about modifying snapshot permissions, see Share * a snapshot in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ResetSnapshotAttributeOutcome ResetSnapshotAttribute(const Model::ResetSnapshotAttributeRequest& request) const; /** * A Callable wrapper for ResetSnapshotAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetSnapshotAttributeOutcomeCallable ResetSnapshotAttributeCallable(const ResetSnapshotAttributeRequestT& request) const { return SubmitCallable(&EC2Client::ResetSnapshotAttribute, request); } /** * An Async wrapper for ResetSnapshotAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetSnapshotAttributeAsync(const ResetSnapshotAttributeRequestT& request, const ResetSnapshotAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::ResetSnapshotAttribute, request, handler, context); } /** *

This action is deprecated.

Restores an Elastic IP * address that was previously moved to the EC2-VPC platform back to the * EC2-Classic platform. You cannot move an Elastic IP address that was originally * allocated for use in EC2-VPC. The Elastic IP address must not be associated with * an instance or network interface.

See Also:

AWS * API Reference

*/ virtual Model::RestoreAddressToClassicOutcome RestoreAddressToClassic(const Model::RestoreAddressToClassicRequest& request) const; /** * A Callable wrapper for RestoreAddressToClassic that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreAddressToClassicOutcomeCallable RestoreAddressToClassicCallable(const RestoreAddressToClassicRequestT& request) const { return SubmitCallable(&EC2Client::RestoreAddressToClassic, request); } /** * An Async wrapper for RestoreAddressToClassic that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreAddressToClassicAsync(const RestoreAddressToClassicRequestT& request, const RestoreAddressToClassicResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RestoreAddressToClassic, request, handler, context); } /** *

Restores an AMI from the Recycle Bin. For more information, see Recycle * Bin in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::RestoreImageFromRecycleBinOutcome RestoreImageFromRecycleBin(const Model::RestoreImageFromRecycleBinRequest& request) const; /** * A Callable wrapper for RestoreImageFromRecycleBin that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreImageFromRecycleBinOutcomeCallable RestoreImageFromRecycleBinCallable(const RestoreImageFromRecycleBinRequestT& request) const { return SubmitCallable(&EC2Client::RestoreImageFromRecycleBin, request); } /** * An Async wrapper for RestoreImageFromRecycleBin that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreImageFromRecycleBinAsync(const RestoreImageFromRecycleBinRequestT& request, const RestoreImageFromRecycleBinResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RestoreImageFromRecycleBin, request, handler, context); } /** *

Restores the entries from a previous version of a managed prefix list to a * new version of the prefix list.

See Also:

AWS * API Reference

*/ virtual Model::RestoreManagedPrefixListVersionOutcome RestoreManagedPrefixListVersion(const Model::RestoreManagedPrefixListVersionRequest& request) const; /** * A Callable wrapper for RestoreManagedPrefixListVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreManagedPrefixListVersionOutcomeCallable RestoreManagedPrefixListVersionCallable(const RestoreManagedPrefixListVersionRequestT& request) const { return SubmitCallable(&EC2Client::RestoreManagedPrefixListVersion, request); } /** * An Async wrapper for RestoreManagedPrefixListVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreManagedPrefixListVersionAsync(const RestoreManagedPrefixListVersionRequestT& request, const RestoreManagedPrefixListVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RestoreManagedPrefixListVersion, request, handler, context); } /** *

Restores a snapshot from the Recycle Bin. For more information, see Restore * snapshots from the Recycle Bin in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::RestoreSnapshotFromRecycleBinOutcome RestoreSnapshotFromRecycleBin(const Model::RestoreSnapshotFromRecycleBinRequest& request) const; /** * A Callable wrapper for RestoreSnapshotFromRecycleBin that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreSnapshotFromRecycleBinOutcomeCallable RestoreSnapshotFromRecycleBinCallable(const RestoreSnapshotFromRecycleBinRequestT& request) const { return SubmitCallable(&EC2Client::RestoreSnapshotFromRecycleBin, request); } /** * An Async wrapper for RestoreSnapshotFromRecycleBin that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreSnapshotFromRecycleBinAsync(const RestoreSnapshotFromRecycleBinRequestT& request, const RestoreSnapshotFromRecycleBinResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RestoreSnapshotFromRecycleBin, request, handler, context); } /** *

Restores an archived Amazon EBS snapshot for use temporarily or permanently, * or modifies the restore period or restore type for a snapshot that was * previously temporarily restored.

For more information see * Restore an archived snapshot and * modify the restore period or restore type for a temporarily restored * snapshot in the Amazon Elastic Compute Cloud User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::RestoreSnapshotTierOutcome RestoreSnapshotTier(const Model::RestoreSnapshotTierRequest& request) const; /** * A Callable wrapper for RestoreSnapshotTier that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreSnapshotTierOutcomeCallable RestoreSnapshotTierCallable(const RestoreSnapshotTierRequestT& request) const { return SubmitCallable(&EC2Client::RestoreSnapshotTier, request); } /** * An Async wrapper for RestoreSnapshotTier that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreSnapshotTierAsync(const RestoreSnapshotTierRequestT& request, const RestoreSnapshotTierResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RestoreSnapshotTier, request, handler, context); } /** *

Removes an ingress authorization rule from a Client VPN endpoint. *

See Also:

AWS * API Reference

*/ virtual Model::RevokeClientVpnIngressOutcome RevokeClientVpnIngress(const Model::RevokeClientVpnIngressRequest& request) const; /** * A Callable wrapper for RevokeClientVpnIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RevokeClientVpnIngressOutcomeCallable RevokeClientVpnIngressCallable(const RevokeClientVpnIngressRequestT& request) const { return SubmitCallable(&EC2Client::RevokeClientVpnIngress, request); } /** * An Async wrapper for RevokeClientVpnIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RevokeClientVpnIngressAsync(const RevokeClientVpnIngressRequestT& request, const RevokeClientVpnIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RevokeClientVpnIngress, request, handler, context); } /** *

Removes the specified outbound (egress) rules from the specified security * group.

You can specify rules using either rule IDs or security group rule * properties. If you use rule properties, the values that you specify (for * example, ports) must match the existing rule's values exactly. Each rule has a * protocol, from and to ports, and destination (CIDR range, security group, or * prefix list). For the TCP and UDP protocols, you must also specify the * destination port or range of ports. For the ICMP protocol, you must also specify * the ICMP type and code. If the security group rule has a description, you do not * need to specify the description to revoke the rule.

For a default VPC, if * the values you specify do not match the existing rule's values, no error is * returned, and the output describes the security group rules that were not * revoked.

Amazon Web Services recommends that you describe the security * group to verify that the rules were removed.

Rule changes are propagated * to instances within the security group as quickly as possible. However, a small * delay might occur.

See Also:

AWS * API Reference

*/ virtual Model::RevokeSecurityGroupEgressOutcome RevokeSecurityGroupEgress(const Model::RevokeSecurityGroupEgressRequest& request) const; /** * A Callable wrapper for RevokeSecurityGroupEgress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RevokeSecurityGroupEgressOutcomeCallable RevokeSecurityGroupEgressCallable(const RevokeSecurityGroupEgressRequestT& request) const { return SubmitCallable(&EC2Client::RevokeSecurityGroupEgress, request); } /** * An Async wrapper for RevokeSecurityGroupEgress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RevokeSecurityGroupEgressAsync(const RevokeSecurityGroupEgressRequestT& request, const RevokeSecurityGroupEgressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RevokeSecurityGroupEgress, request, handler, context); } /** *

Removes the specified inbound (ingress) rules from a security group.

*

You can specify rules using either rule IDs or security group rule * properties. If you use rule properties, the values that you specify (for * example, ports) must match the existing rule's values exactly. Each rule has a * protocol, from and to ports, and source (CIDR range, security group, or prefix * list). For the TCP and UDP protocols, you must also specify the destination port * or range of ports. For the ICMP protocol, you must also specify the ICMP type * and code. If the security group rule has a description, you do not need to * specify the description to revoke the rule.

For a default VPC, if the * values you specify do not match the existing rule's values, no error is * returned, and the output describes the security group rules that were not * revoked.

Amazon Web Services recommends that you describe the security * group to verify that the rules were removed.

Rule changes are propagated * to instances within the security group as quickly as possible. However, a small * delay might occur.

See Also:

AWS * API Reference

*/ virtual Model::RevokeSecurityGroupIngressOutcome RevokeSecurityGroupIngress(const Model::RevokeSecurityGroupIngressRequest& request) const; /** * A Callable wrapper for RevokeSecurityGroupIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RevokeSecurityGroupIngressOutcomeCallable RevokeSecurityGroupIngressCallable(const RevokeSecurityGroupIngressRequestT& request) const { return SubmitCallable(&EC2Client::RevokeSecurityGroupIngress, request); } /** * An Async wrapper for RevokeSecurityGroupIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RevokeSecurityGroupIngressAsync(const RevokeSecurityGroupIngressRequestT& request, const RevokeSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RevokeSecurityGroupIngress, request, handler, context); } /** *

Launches the specified number of instances using an AMI for which you have * permissions.

You can specify a number of options, or leave the default * options. The following rules apply:

  • If you don't specify a * subnet ID, we choose a default subnet from your default VPC for you. If you * don't have a default VPC, you must specify a subnet ID in the request.

    • *

  • All instances have a network interface with a primary private IPv4 * address. If you don't specify this address, we choose one from the IPv4 range of * your subnet.

  • Not all instance types support IPv6 addresses. * For more information, see Instance * types.

  • If you don't specify a security group ID, we use * the default security group. For more information, see Security * groups.

  • If any of the AMIs have a product code attached * for which the user has not subscribed, the request fails.

You * can create a launch * template, which is a resource that contains the parameters to launch an * instance. When you launch an instance using RunInstances, you can specify * the launch template instead of specifying the launch parameters.

To * ensure faster instance launches, break up large requests into smaller batches. * For example, create five separate launch requests for 100 instances each instead * of one launch request for 500 instances.

An instance is ready for you to * use when it's in the running state. You can check the state of your * instance using DescribeInstances. You can tag instances and EBS volumes * during launch, after launch, or both. For more information, see * CreateTags and Tagging * your Amazon EC2 resources.

Linux instances have access to the public * key of the key pair at boot. You can use this key to provide secure access to * the instance. Amazon EC2 public images use this feature to provide secure access * without passwords. For more information, see Key * pairs.

For troubleshooting, see What * to do if an instance immediately terminates, and Troubleshooting * connecting to your instance.

See Also:

AWS * API Reference

*/ virtual Model::RunInstancesOutcome RunInstances(const Model::RunInstancesRequest& request) const; /** * A Callable wrapper for RunInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RunInstancesOutcomeCallable RunInstancesCallable(const RunInstancesRequestT& request) const { return SubmitCallable(&EC2Client::RunInstances, request); } /** * An Async wrapper for RunInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RunInstancesAsync(const RunInstancesRequestT& request, const RunInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RunInstances, request, handler, context); } /** *

Launches the specified Scheduled Instances.

Before you can launch a * Scheduled Instance, you must purchase it and obtain an identifier using * PurchaseScheduledInstances.

You must launch a Scheduled Instance * during its scheduled time period. You can't stop or reboot a Scheduled Instance, * but you can terminate it as needed. If you terminate a Scheduled Instance before * the current scheduled time period ends, you can launch it again after a few * minutes. For more information, see Scheduled * Instances in the Amazon EC2 User Guide.

See Also:

AWS * API Reference

*/ virtual Model::RunScheduledInstancesOutcome RunScheduledInstances(const Model::RunScheduledInstancesRequest& request) const; /** * A Callable wrapper for RunScheduledInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RunScheduledInstancesOutcomeCallable RunScheduledInstancesCallable(const RunScheduledInstancesRequestT& request) const { return SubmitCallable(&EC2Client::RunScheduledInstances, request); } /** * An Async wrapper for RunScheduledInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RunScheduledInstancesAsync(const RunScheduledInstancesRequestT& request, const RunScheduledInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::RunScheduledInstances, request, handler, context); } /** *

Searches for routes in the specified local gateway route table.

See * Also:

AWS * API Reference

*/ virtual Model::SearchLocalGatewayRoutesOutcome SearchLocalGatewayRoutes(const Model::SearchLocalGatewayRoutesRequest& request) const; /** * A Callable wrapper for SearchLocalGatewayRoutes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchLocalGatewayRoutesOutcomeCallable SearchLocalGatewayRoutesCallable(const SearchLocalGatewayRoutesRequestT& request) const { return SubmitCallable(&EC2Client::SearchLocalGatewayRoutes, request); } /** * An Async wrapper for SearchLocalGatewayRoutes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchLocalGatewayRoutesAsync(const SearchLocalGatewayRoutesRequestT& request, const SearchLocalGatewayRoutesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::SearchLocalGatewayRoutes, request, handler, context); } /** *

Searches one or more transit gateway multicast groups and returns the group * membership information.

See Also:

AWS * API Reference

*/ virtual Model::SearchTransitGatewayMulticastGroupsOutcome SearchTransitGatewayMulticastGroups(const Model::SearchTransitGatewayMulticastGroupsRequest& request) const; /** * A Callable wrapper for SearchTransitGatewayMulticastGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchTransitGatewayMulticastGroupsOutcomeCallable SearchTransitGatewayMulticastGroupsCallable(const SearchTransitGatewayMulticastGroupsRequestT& request) const { return SubmitCallable(&EC2Client::SearchTransitGatewayMulticastGroups, request); } /** * An Async wrapper for SearchTransitGatewayMulticastGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchTransitGatewayMulticastGroupsAsync(const SearchTransitGatewayMulticastGroupsRequestT& request, const SearchTransitGatewayMulticastGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::SearchTransitGatewayMulticastGroups, request, handler, context); } /** *

Searches for routes in the specified transit gateway route * table.

See Also:

AWS * API Reference

*/ virtual Model::SearchTransitGatewayRoutesOutcome SearchTransitGatewayRoutes(const Model::SearchTransitGatewayRoutesRequest& request) const; /** * A Callable wrapper for SearchTransitGatewayRoutes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchTransitGatewayRoutesOutcomeCallable SearchTransitGatewayRoutesCallable(const SearchTransitGatewayRoutesRequestT& request) const { return SubmitCallable(&EC2Client::SearchTransitGatewayRoutes, request); } /** * An Async wrapper for SearchTransitGatewayRoutes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchTransitGatewayRoutesAsync(const SearchTransitGatewayRoutesRequestT& request, const SearchTransitGatewayRoutesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::SearchTransitGatewayRoutes, request, handler, context); } /** *

Sends a diagnostic interrupt to the specified Amazon EC2 instance to trigger * a kernel panic (on Linux instances), or a blue screen/stop * error (on Windows instances). For instances based on Intel and AMD * processors, the interrupt is received as a non-maskable interrupt * (NMI).

In general, the operating system crashes and reboots when a kernel * panic or stop error is triggered. The operating system can also be configured to * perform diagnostic tasks, such as generating a memory dump file, loading a * secondary kernel, or obtaining a call trace.

Before sending a diagnostic * interrupt to your instance, ensure that its operating system is configured to * perform the required diagnostic tasks.

For more information about * configuring your operating system to generate a crash dump when a kernel panic * or stop error occurs, see Send * a diagnostic interrupt (for advanced users) (Linux instances) or Send * a diagnostic interrupt (for advanced users) (Windows * instances).

See Also:

AWS * API Reference

*/ virtual Model::SendDiagnosticInterruptOutcome SendDiagnosticInterrupt(const Model::SendDiagnosticInterruptRequest& request) const; /** * A Callable wrapper for SendDiagnosticInterrupt that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendDiagnosticInterruptOutcomeCallable SendDiagnosticInterruptCallable(const SendDiagnosticInterruptRequestT& request) const { return SubmitCallable(&EC2Client::SendDiagnosticInterrupt, request); } /** * An Async wrapper for SendDiagnosticInterrupt that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendDiagnosticInterruptAsync(const SendDiagnosticInterruptRequestT& request, const SendDiagnosticInterruptResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::SendDiagnosticInterrupt, request, handler, context); } /** *

Starts an Amazon EBS-backed instance that you've previously stopped.

*

Instances that use Amazon EBS volumes as their root devices can be quickly * stopped and started. When an instance is stopped, the compute resources are * released and you are not billed for instance usage. However, your root partition * Amazon EBS volume remains and continues to persist your data, and you are * charged for Amazon EBS volume usage. You can restart your instance at any time. * Every time you start your instance, Amazon EC2 charges a one-minute minimum for * instance usage, and thereafter charges per second for instance usage.

*

Before stopping an instance, make sure it is in a state from which it can be * restarted. Stopping an instance does not preserve data stored in RAM.

*

Performing this operation on an instance that uses an instance store as its * root device returns an error.

If you attempt to start a T3 instance with * host tenancy and the unlimted CPU credit option, the * request fails. The unlimited CPU credit option is not supported on * Dedicated Hosts. Before you start the instance, either change its CPU credit * option to standard, or change its tenancy to default * or dedicated.

For more information, see Stop * and start your instance in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::StartInstancesOutcome StartInstances(const Model::StartInstancesRequest& request) const; /** * A Callable wrapper for StartInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartInstancesOutcomeCallable StartInstancesCallable(const StartInstancesRequestT& request) const { return SubmitCallable(&EC2Client::StartInstances, request); } /** * An Async wrapper for StartInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartInstancesAsync(const StartInstancesRequestT& request, const StartInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::StartInstances, request, handler, context); } /** *

Starts analyzing the specified Network Access Scope.

See Also:

* AWS * API Reference

*/ virtual Model::StartNetworkInsightsAccessScopeAnalysisOutcome StartNetworkInsightsAccessScopeAnalysis(const Model::StartNetworkInsightsAccessScopeAnalysisRequest& request) const; /** * A Callable wrapper for StartNetworkInsightsAccessScopeAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartNetworkInsightsAccessScopeAnalysisOutcomeCallable StartNetworkInsightsAccessScopeAnalysisCallable(const StartNetworkInsightsAccessScopeAnalysisRequestT& request) const { return SubmitCallable(&EC2Client::StartNetworkInsightsAccessScopeAnalysis, request); } /** * An Async wrapper for StartNetworkInsightsAccessScopeAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartNetworkInsightsAccessScopeAnalysisAsync(const StartNetworkInsightsAccessScopeAnalysisRequestT& request, const StartNetworkInsightsAccessScopeAnalysisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::StartNetworkInsightsAccessScopeAnalysis, request, handler, context); } /** *

Starts analyzing the specified path. If the path is reachable, the operation * returns the shortest feasible path.

See Also:

AWS * API Reference

*/ virtual Model::StartNetworkInsightsAnalysisOutcome StartNetworkInsightsAnalysis(const Model::StartNetworkInsightsAnalysisRequest& request) const; /** * A Callable wrapper for StartNetworkInsightsAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartNetworkInsightsAnalysisOutcomeCallable StartNetworkInsightsAnalysisCallable(const StartNetworkInsightsAnalysisRequestT& request) const { return SubmitCallable(&EC2Client::StartNetworkInsightsAnalysis, request); } /** * An Async wrapper for StartNetworkInsightsAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartNetworkInsightsAnalysisAsync(const StartNetworkInsightsAnalysisRequestT& request, const StartNetworkInsightsAnalysisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::StartNetworkInsightsAnalysis, request, handler, context); } /** *

Initiates the verification process to prove that the service provider owns * the private DNS name domain for the endpoint service.

The service * provider must successfully perform the verification before the consumer can use * the name to access the service.

Before the service provider runs this * command, they must add a record to the DNS server.

See Also:

AWS * API Reference

*/ virtual Model::StartVpcEndpointServicePrivateDnsVerificationOutcome StartVpcEndpointServicePrivateDnsVerification(const Model::StartVpcEndpointServicePrivateDnsVerificationRequest& request) const; /** * A Callable wrapper for StartVpcEndpointServicePrivateDnsVerification that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartVpcEndpointServicePrivateDnsVerificationOutcomeCallable StartVpcEndpointServicePrivateDnsVerificationCallable(const StartVpcEndpointServicePrivateDnsVerificationRequestT& request) const { return SubmitCallable(&EC2Client::StartVpcEndpointServicePrivateDnsVerification, request); } /** * An Async wrapper for StartVpcEndpointServicePrivateDnsVerification that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartVpcEndpointServicePrivateDnsVerificationAsync(const StartVpcEndpointServicePrivateDnsVerificationRequestT& request, const StartVpcEndpointServicePrivateDnsVerificationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::StartVpcEndpointServicePrivateDnsVerification, request, handler, context); } /** *

Stops an Amazon EBS-backed instance. For more information, see Stop * and start your instance in the Amazon EC2 User Guide.

You can * use the Stop action to hibernate an instance if the instance is enabled * for hibernation and it meets the hibernation * prerequisites. For more information, see Hibernate * your instance in the Amazon EC2 User Guide.

We don't charge * usage for a stopped instance, or data transfer fees; however, your root * partition Amazon EBS volume remains and continues to persist your data, and you * are charged for Amazon EBS volume usage. Every time you start your instance, * Amazon EC2 charges a one-minute minimum for instance usage, and thereafter * charges per second for instance usage.

You can't stop or hibernate * instance store-backed instances. You can't use the Stop action to hibernate Spot * Instances, but you can specify that Amazon EC2 should hibernate Spot Instances * when they are interrupted. For more information, see Hibernating * interrupted Spot Instances in the Amazon EC2 User Guide.

When * you stop or hibernate an instance, we shut it down. You can restart your * instance at any time. Before stopping or hibernating an instance, make sure it * is in a state from which it can be restarted. Stopping an instance does not * preserve data stored in RAM, but hibernating an instance does preserve data * stored in RAM. If an instance cannot hibernate successfully, a normal shutdown * occurs.

Stopping and hibernating an instance is different to rebooting or * terminating it. For example, when you stop or hibernate an instance, the root * device and any other devices attached to the instance persist. When you * terminate an instance, the root device and any other devices attached during the * instance launch are automatically deleted. For more information about the * differences between rebooting, stopping, hibernating, and terminating instances, * see Instance * lifecycle in the Amazon EC2 User Guide.

When you stop an * instance, we attempt to shut it down forcibly after a short while. If your * instance appears stuck in the stopping state after a period of time, there may * be an issue with the underlying host computer. For more information, see Troubleshoot * stopping your instance in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::StopInstancesOutcome StopInstances(const Model::StopInstancesRequest& request) const; /** * A Callable wrapper for StopInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopInstancesOutcomeCallable StopInstancesCallable(const StopInstancesRequestT& request) const { return SubmitCallable(&EC2Client::StopInstances, request); } /** * An Async wrapper for StopInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopInstancesAsync(const StopInstancesRequestT& request, const StopInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::StopInstances, request, handler, context); } /** *

Terminates active Client VPN endpoint connections. This action can be used to * terminate a specific client connection, or up to five connections established by * a specific user.

See Also:

AWS * API Reference

*/ virtual Model::TerminateClientVpnConnectionsOutcome TerminateClientVpnConnections(const Model::TerminateClientVpnConnectionsRequest& request) const; /** * A Callable wrapper for TerminateClientVpnConnections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TerminateClientVpnConnectionsOutcomeCallable TerminateClientVpnConnectionsCallable(const TerminateClientVpnConnectionsRequestT& request) const { return SubmitCallable(&EC2Client::TerminateClientVpnConnections, request); } /** * An Async wrapper for TerminateClientVpnConnections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TerminateClientVpnConnectionsAsync(const TerminateClientVpnConnectionsRequestT& request, const TerminateClientVpnConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::TerminateClientVpnConnections, request, handler, context); } /** *

Shuts down the specified instances. This operation is idempotent; if you * terminate an instance more than once, each call succeeds.

If you specify * multiple instances and the request fails (for example, because of a single * incorrect instance ID), none of the instances are terminated.

If you * terminate multiple instances across multiple Availability Zones, and one or more * of the specified instances are enabled for termination protection, the request * fails with the following results:

  • The specified instances that * are in the same Availability Zone as the protected instance are not * terminated.

  • The specified instances that are in different * Availability Zones, where no other specified instances are protected, are * successfully terminated.

For example, say you have the * following instances:

  • Instance A: us-east-1a; Not * protected

  • Instance B: us-east-1a; Not * protected

  • Instance C: us-east-1b; Protected

    *

  • Instance D: us-east-1b; not protected

*

If you attempt to terminate all of these instances in the same request, the * request reports failure with the following results:

  • Instance A * and Instance B are successfully terminated because none of the specified * instances in us-east-1a are enabled for termination protection.

    *

  • Instance C and Instance D fail to terminate because at least one * of the specified instances in us-east-1b (Instance C) is enabled * for termination protection.

Terminated instances remain * visible after termination (for approximately one hour).

By default, * Amazon EC2 deletes all EBS volumes that were attached when the instance * launched. Volumes attached after instance launch continue running.

You * can stop, start, and terminate EBS-backed instances. You can only terminate * instance store-backed instances. What happens to an instance differs if you stop * it or terminate it. For example, when you stop an instance, the root device and * any other devices attached to the instance persist. When you terminate an * instance, any attached EBS volumes with the DeleteOnTermination * block device mapping parameter set to true are automatically * deleted. For more information about the differences between stopping and * terminating instances, see Instance * lifecycle in the Amazon EC2 User Guide.

For more information * about troubleshooting, see Troubleshooting * terminating your instance in the Amazon EC2 User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::TerminateInstancesOutcome TerminateInstances(const Model::TerminateInstancesRequest& request) const; /** * A Callable wrapper for TerminateInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TerminateInstancesOutcomeCallable TerminateInstancesCallable(const TerminateInstancesRequestT& request) const { return SubmitCallable(&EC2Client::TerminateInstances, request); } /** * An Async wrapper for TerminateInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TerminateInstancesAsync(const TerminateInstancesRequestT& request, const TerminateInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::TerminateInstances, request, handler, context); } /** *

Unassigns one or more IPv6 addresses IPv4 Prefix Delegation prefixes from a * network interface.

See Also:

AWS * API Reference

*/ virtual Model::UnassignIpv6AddressesOutcome UnassignIpv6Addresses(const Model::UnassignIpv6AddressesRequest& request) const; /** * A Callable wrapper for UnassignIpv6Addresses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UnassignIpv6AddressesOutcomeCallable UnassignIpv6AddressesCallable(const UnassignIpv6AddressesRequestT& request) const { return SubmitCallable(&EC2Client::UnassignIpv6Addresses, request); } /** * An Async wrapper for UnassignIpv6Addresses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UnassignIpv6AddressesAsync(const UnassignIpv6AddressesRequestT& request, const UnassignIpv6AddressesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::UnassignIpv6Addresses, request, handler, context); } /** *

Unassigns one or more secondary private IP addresses, or IPv4 Prefix * Delegation prefixes from a network interface.

See Also:

AWS * API Reference

*/ virtual Model::UnassignPrivateIpAddressesOutcome UnassignPrivateIpAddresses(const Model::UnassignPrivateIpAddressesRequest& request) const; /** * A Callable wrapper for UnassignPrivateIpAddresses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UnassignPrivateIpAddressesOutcomeCallable UnassignPrivateIpAddressesCallable(const UnassignPrivateIpAddressesRequestT& request) const { return SubmitCallable(&EC2Client::UnassignPrivateIpAddresses, request); } /** * An Async wrapper for UnassignPrivateIpAddresses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UnassignPrivateIpAddressesAsync(const UnassignPrivateIpAddressesRequestT& request, const UnassignPrivateIpAddressesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::UnassignPrivateIpAddresses, request, handler, context); } /** *

Unassigns secondary private IPv4 addresses from a private NAT gateway. You * cannot unassign your primary private IP. For more information, see Edit * secondary IP address associations in the Amazon VPC User Guide.

*

While unassigning is in progress, you cannot assign/unassign additional IP * addresses while the connections are being drained. You are, however, allowed to * delete the NAT gateway.

A private IP address will only be released at the * end of MaxDrainDurationSeconds. The private IP addresses stay associated and * support the existing connections, but do not support any new connections (new * connections are distributed across the remaining assigned private IP address). * After the existing connections drain out, the private IP addresses are * released.

See Also:

AWS * API Reference

*/ virtual Model::UnassignPrivateNatGatewayAddressOutcome UnassignPrivateNatGatewayAddress(const Model::UnassignPrivateNatGatewayAddressRequest& request) const; /** * A Callable wrapper for UnassignPrivateNatGatewayAddress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UnassignPrivateNatGatewayAddressOutcomeCallable UnassignPrivateNatGatewayAddressCallable(const UnassignPrivateNatGatewayAddressRequestT& request) const { return SubmitCallable(&EC2Client::UnassignPrivateNatGatewayAddress, request); } /** * An Async wrapper for UnassignPrivateNatGatewayAddress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UnassignPrivateNatGatewayAddressAsync(const UnassignPrivateNatGatewayAddressRequestT& request, const UnassignPrivateNatGatewayAddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::UnassignPrivateNatGatewayAddress, request, handler, context); } /** *

Disables detailed monitoring for a running instance. For more information, * see Monitoring * your instances and volumes in the Amazon EC2 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UnmonitorInstancesOutcome UnmonitorInstances(const Model::UnmonitorInstancesRequest& request) const; /** * A Callable wrapper for UnmonitorInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UnmonitorInstancesOutcomeCallable UnmonitorInstancesCallable(const UnmonitorInstancesRequestT& request) const { return SubmitCallable(&EC2Client::UnmonitorInstances, request); } /** * An Async wrapper for UnmonitorInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UnmonitorInstancesAsync(const UnmonitorInstancesRequestT& request, const UnmonitorInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::UnmonitorInstances, request, handler, context); } /** *

Updates the description of an egress (outbound) security group rule. You can * replace an existing description, or add a description to a rule that did not * have one previously. You can remove a description for a security group rule by * omitting the description parameter in the request.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSecurityGroupRuleDescriptionsEgressOutcome UpdateSecurityGroupRuleDescriptionsEgress(const Model::UpdateSecurityGroupRuleDescriptionsEgressRequest& request) const; /** * A Callable wrapper for UpdateSecurityGroupRuleDescriptionsEgress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSecurityGroupRuleDescriptionsEgressOutcomeCallable UpdateSecurityGroupRuleDescriptionsEgressCallable(const UpdateSecurityGroupRuleDescriptionsEgressRequestT& request) const { return SubmitCallable(&EC2Client::UpdateSecurityGroupRuleDescriptionsEgress, request); } /** * An Async wrapper for UpdateSecurityGroupRuleDescriptionsEgress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSecurityGroupRuleDescriptionsEgressAsync(const UpdateSecurityGroupRuleDescriptionsEgressRequestT& request, const UpdateSecurityGroupRuleDescriptionsEgressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::UpdateSecurityGroupRuleDescriptionsEgress, request, handler, context); } /** *

Updates the description of an ingress (inbound) security group rule. You can * replace an existing description, or add a description to a rule that did not * have one previously. You can remove a description for a security group rule by * omitting the description parameter in the request.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSecurityGroupRuleDescriptionsIngressOutcome UpdateSecurityGroupRuleDescriptionsIngress(const Model::UpdateSecurityGroupRuleDescriptionsIngressRequest& request) const; /** * A Callable wrapper for UpdateSecurityGroupRuleDescriptionsIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSecurityGroupRuleDescriptionsIngressOutcomeCallable UpdateSecurityGroupRuleDescriptionsIngressCallable(const UpdateSecurityGroupRuleDescriptionsIngressRequestT& request) const { return SubmitCallable(&EC2Client::UpdateSecurityGroupRuleDescriptionsIngress, request); } /** * An Async wrapper for UpdateSecurityGroupRuleDescriptionsIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSecurityGroupRuleDescriptionsIngressAsync(const UpdateSecurityGroupRuleDescriptionsIngressRequestT& request, const UpdateSecurityGroupRuleDescriptionsIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::UpdateSecurityGroupRuleDescriptionsIngress, request, handler, context); } /** *

Stops advertising an address range that is provisioned as an address * pool.

You can perform this operation at most once every 10 seconds, even * if you specify different address ranges each time.

It can take a few * minutes before traffic to the specified addresses stops routing to Amazon Web * Services because of BGP propagation delays.

See Also:

AWS * API Reference

*/ virtual Model::WithdrawByoipCidrOutcome WithdrawByoipCidr(const Model::WithdrawByoipCidrRequest& request) const; /** * A Callable wrapper for WithdrawByoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::WithdrawByoipCidrOutcomeCallable WithdrawByoipCidrCallable(const WithdrawByoipCidrRequestT& request) const { return SubmitCallable(&EC2Client::WithdrawByoipCidr, request); } /** * An Async wrapper for WithdrawByoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void WithdrawByoipCidrAsync(const WithdrawByoipCidrRequestT& request, const WithdrawByoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&EC2Client::WithdrawByoipCidr, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const EC2ClientConfiguration& clientConfiguration); EC2ClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace EC2 } // namespace Aws