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

#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/ec2/EC2PaginationBase.h>
#include <aws/ec2/EC2ServiceClientModel.h>
#include <aws/ec2/EC2Waiter.h>
#include <aws/ec2/EC2_EXPORTS.h>

namespace Aws {
namespace EC2 {
/**
 * <fullname>Amazon Elastic Compute Cloud</fullname> <p>You can access the features
 * of Amazon Elastic Compute Cloud (Amazon EC2) programmatically. For more
 * information, see the <a
 * href="https://docs.aws.amazon.com/ec2/latest/devguide">Amazon EC2 Developer
 * Guide</a>.</p>
 */
class AWS_EC2_API EC2Client : public Aws::Client::AWSXMLClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<EC2Client>,
                              public EC2PaginationBase<EC2Client>,
                              public EC2Waiter<EC2Client> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();

  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<EC2EndpointProviderBase> endpointProvider = nullptr);

  /**
   * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
   * is not specified, it will be initialized to default values.
   */
  EC2Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<EC2EndpointProviderBase> endpointProvider = nullptr,
            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<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<EC2EndpointProviderBase> endpointProvider = nullptr,
            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<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);

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

  /**
   * <p>Accepts an Elastic IP address transfer. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#using-instance-addressing-eips-transfer-accept">Accept
   * a transferred Elastic IP address</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptAddressTransfer">AWS
   * API Reference</a></p>
   */
  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 <typename AcceptAddressTransferRequestT = Model::AcceptAddressTransferRequest>
  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 <typename AcceptAddressTransferRequestT = Model::AcceptAddressTransferRequest>
  void AcceptAddressTransferAsync(const AcceptAddressTransferRequestT& request, const AcceptAddressTransferResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AcceptAddressTransfer, request, handler, context);
  }

  /**
   * <p>Accepts a request to assign billing of the available capacity of a shared
   * Capacity Reservation to your account. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/assign-billing.html">
   * Billing assignment for shared Amazon EC2 Capacity
   * Reservations</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptCapacityReservationBillingOwnership">AWS
   * API Reference</a></p>
   */
  virtual Model::AcceptCapacityReservationBillingOwnershipOutcome AcceptCapacityReservationBillingOwnership(
      const Model::AcceptCapacityReservationBillingOwnershipRequest& request) const;

  /**
   * A Callable wrapper for AcceptCapacityReservationBillingOwnership that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename AcceptCapacityReservationBillingOwnershipRequestT = Model::AcceptCapacityReservationBillingOwnershipRequest>
  Model::AcceptCapacityReservationBillingOwnershipOutcomeCallable AcceptCapacityReservationBillingOwnershipCallable(
      const AcceptCapacityReservationBillingOwnershipRequestT& request) const {
    return SubmitCallable(&EC2Client::AcceptCapacityReservationBillingOwnership, request);
  }

  /**
   * An Async wrapper for AcceptCapacityReservationBillingOwnership that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename AcceptCapacityReservationBillingOwnershipRequestT = Model::AcceptCapacityReservationBillingOwnershipRequest>
  void AcceptCapacityReservationBillingOwnershipAsync(
      const AcceptCapacityReservationBillingOwnershipRequestT& request,
      const AcceptCapacityReservationBillingOwnershipResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AcceptCapacityReservationBillingOwnership, request, handler, context);
  }

  /**
   * <p>Accepts the Convertible Reserved Instance exchange quote described in the
   * <a>GetReservedInstancesExchangeQuote</a> call.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptReservedInstancesExchangeQuote">AWS
   * API Reference</a></p>
   */
  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 <typename AcceptReservedInstancesExchangeQuoteRequestT = Model::AcceptReservedInstancesExchangeQuoteRequest>
  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 <typename AcceptReservedInstancesExchangeQuoteRequestT = Model::AcceptReservedInstancesExchangeQuoteRequest>
  void AcceptReservedInstancesExchangeQuoteAsync(const AcceptReservedInstancesExchangeQuoteRequestT& request,
                                                 const AcceptReservedInstancesExchangeQuoteResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AcceptReservedInstancesExchangeQuote, request, handler, context);
  }

  /**
   * <p>Accepts a request to associate subnets with a transit gateway multicast
   * domain.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayMulticastDomainAssociations">AWS
   * API Reference</a></p>
   */
  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 <
      typename AcceptTransitGatewayMulticastDomainAssociationsRequestT = Model::AcceptTransitGatewayMulticastDomainAssociationsRequest>
  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 <
      typename AcceptTransitGatewayMulticastDomainAssociationsRequestT = Model::AcceptTransitGatewayMulticastDomainAssociationsRequest>
  void AcceptTransitGatewayMulticastDomainAssociationsAsync(
      const AcceptTransitGatewayMulticastDomainAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const AcceptTransitGatewayMulticastDomainAssociationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::AcceptTransitGatewayMulticastDomainAssociations, request, handler, context);
  }

  /**
   * <p>Accepts a transit gateway peering attachment request. The peering attachment
   * must be in the <code>pendingAcceptance</code> state.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayPeeringAttachment">AWS
   * API Reference</a></p>
   */
  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 <typename AcceptTransitGatewayPeeringAttachmentRequestT = Model::AcceptTransitGatewayPeeringAttachmentRequest>
  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 <typename AcceptTransitGatewayPeeringAttachmentRequestT = Model::AcceptTransitGatewayPeeringAttachmentRequest>
  void AcceptTransitGatewayPeeringAttachmentAsync(const AcceptTransitGatewayPeeringAttachmentRequestT& request,
                                                  const AcceptTransitGatewayPeeringAttachmentResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AcceptTransitGatewayPeeringAttachment, request, handler, context);
  }

  /**
   * <p>Accepts a request to attach a VPC to a transit gateway.</p> <p>The VPC
   * attachment must be in the <code>pendingAcceptance</code> state. Use
   * <a>DescribeTransitGatewayVpcAttachments</a> to view your pending VPC attachment
   * requests. Use <a>RejectTransitGatewayVpcAttachment</a> to reject a VPC
   * attachment request.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayVpcAttachment">AWS
   * API Reference</a></p>
   */
  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 <typename AcceptTransitGatewayVpcAttachmentRequestT = Model::AcceptTransitGatewayVpcAttachmentRequest>
  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 <typename AcceptTransitGatewayVpcAttachmentRequestT = Model::AcceptTransitGatewayVpcAttachmentRequest>
  void AcceptTransitGatewayVpcAttachmentAsync(const AcceptTransitGatewayVpcAttachmentRequestT& request,
                                              const AcceptTransitGatewayVpcAttachmentResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AcceptTransitGatewayVpcAttachment, request, handler, context);
  }

  /**
   * <p>Accepts connection requests to your VPC endpoint service.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcEndpointConnections">AWS
   * API Reference</a></p>
   */
  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 <typename AcceptVpcEndpointConnectionsRequestT = Model::AcceptVpcEndpointConnectionsRequest>
  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 <typename AcceptVpcEndpointConnectionsRequestT = Model::AcceptVpcEndpointConnectionsRequest>
  void AcceptVpcEndpointConnectionsAsync(const AcceptVpcEndpointConnectionsRequestT& request,
                                         const AcceptVpcEndpointConnectionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AcceptVpcEndpointConnections, request, handler, context);
  }

  /**
   * <p>Accept a VPC peering connection request. To accept a request, the VPC peering
   * connection must be in the <code>pending-acceptance</code> state, and you must be
   * the owner of the peer VPC. Use <a>DescribeVpcPeeringConnections</a> to view your
   * outstanding VPC peering connection requests.</p> <p>For an inter-Region VPC
   * peering connection request, you must accept the VPC peering connection in the
   * Region of the accepter VPC.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcPeeringConnection">AWS
   * API Reference</a></p>
   */
  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 <typename AcceptVpcPeeringConnectionRequestT = Model::AcceptVpcPeeringConnectionRequest>
  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 <typename AcceptVpcPeeringConnectionRequestT = Model::AcceptVpcPeeringConnectionRequest>
  void AcceptVpcPeeringConnectionAsync(const AcceptVpcPeeringConnectionRequestT& request,
                                       const AcceptVpcPeeringConnectionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AcceptVpcPeeringConnection, request, handler, context);
  }

  /**
   * <p>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).</p> <p>You can perform this operation at most once every 10 seconds,
   * even if you specify different address ranges each time.</p> <p>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.</p> <p>It can
   * take a few minutes before traffic to the specified addresses starts routing to
   * Amazon Web Services because of BGP propagation delays.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AdvertiseByoipCidr">AWS
   * API Reference</a></p>
   */
  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 <typename AdvertiseByoipCidrRequestT = Model::AdvertiseByoipCidrRequest>
  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 <typename AdvertiseByoipCidrRequestT = Model::AdvertiseByoipCidrRequest>
  void AdvertiseByoipCidrAsync(const AdvertiseByoipCidrRequestT& request, const AdvertiseByoipCidrResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AdvertiseByoipCidr, request, handler, context);
  }

  /**
   * <p>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.</p> <p>You can allocate an Elastic IP address from one of the following
   * address pools:</p> <ul> <li> <p>Amazon's pool of IPv4 addresses</p> </li> <li>
   * <p>Public IPv4 address range that you own and bring to your Amazon Web Services
   * account using <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">Bring
   * Your Own IP Addresses (BYOIP)</a> </p> </li> <li> <p>An IPv4 IPAM pool with an
   * Amazon-provided or BYOIP public IPv4 address range</p> </li> <li> <p>IPv4
   * addresses from your on-premises network made available for use with an Outpost
   * using a <a
   * href="https://docs.aws.amazon.com/outposts/latest/userguide/routing.html#ip-addressing">customer-owned
   * IP address pool</a> (CoIP pool)</p> </li> </ul> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html">Elastic
   * IP Addresses</a> in the <i>Amazon EC2 User Guide</i>.</p> <p>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.</p> <p>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).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateAddress">AWS
   * API Reference</a></p>
   */
  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 <typename AllocateAddressRequestT = Model::AllocateAddressRequest>
  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 <typename AllocateAddressRequestT = Model::AllocateAddressRequest>
  void AllocateAddressAsync(const AllocateAddressResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const AllocateAddressRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::AllocateAddress, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateHosts">AWS
   * API Reference</a></p>
   */
  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 <typename AllocateHostsRequestT = Model::AllocateHostsRequest>
  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 <typename AllocateHostsRequestT = Model::AllocateHostsRequest>
  void AllocateHostsAsync(const AllocateHostsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const AllocateHostsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::AllocateHosts, request, handler, context);
  }

  /**
   * <p>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.</p> <p>In IPAM, an allocation is a CIDR assignment
   * from an IPAM pool to another IPAM pool or to a resource. For more information,
   * see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/allocate-cidrs-ipam.html">Allocate
   * CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.</p>  <p>This action
   * creates an allocation with strong consistency. The returned CIDR will not
   * overlap with any other allocations from the same pool.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateIpamPoolCidr">AWS
   * API Reference</a></p>
   */
  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 <typename AllocateIpamPoolCidrRequestT = Model::AllocateIpamPoolCidrRequest>
  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 <typename AllocateIpamPoolCidrRequestT = Model::AllocateIpamPoolCidrRequest>
  void AllocateIpamPoolCidrAsync(const AllocateIpamPoolCidrRequestT& request, const AllocateIpamPoolCidrResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AllocateIpamPoolCidr, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ApplySecurityGroupsToClientVpnTargetNetwork">AWS
   * API Reference</a></p>
   */
  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 <typename ApplySecurityGroupsToClientVpnTargetNetworkRequestT = Model::ApplySecurityGroupsToClientVpnTargetNetworkRequest>
  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 <typename ApplySecurityGroupsToClientVpnTargetNetworkRequestT = Model::ApplySecurityGroupsToClientVpnTargetNetworkRequest>
  void ApplySecurityGroupsToClientVpnTargetNetworkAsync(
      const ApplySecurityGroupsToClientVpnTargetNetworkRequestT& request,
      const ApplySecurityGroupsToClientVpnTargetNetworkResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ApplySecurityGroupsToClientVpnTargetNetwork, request, handler, context);
  }

  /**
   * <p>Assigns the specified IPv6 addresses to the specified network interface. You
   * can specify specific IPv6 addresses, or you can specify the number of IPv6
   * addresses to be automatically assigned from 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 by instance type.</p> <p>You must
   * specify either the IPv6 addresses or the IPv6 address count in the request. </p>
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html">
   * Assigning prefixes to network interfaces</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignIpv6Addresses">AWS
   * API Reference</a></p>
   */
  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 <typename AssignIpv6AddressesRequestT = Model::AssignIpv6AddressesRequest>
  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 <typename AssignIpv6AddressesRequestT = Model::AssignIpv6AddressesRequest>
  void AssignIpv6AddressesAsync(const AssignIpv6AddressesRequestT& request, const AssignIpv6AddressesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssignIpv6Addresses, request, handler, context);
  }

  /**
   * <p>Assigns the specified secondary private IP addresses to the specified network
   * interface.</p> <p>You can specify specific secondary IP addresses, or you can
   * specify the number of secondary IP addresses to be automatically assigned from
   * the subnet's CIDR block range. The number of secondary IP addresses that you can
   * assign to an instance varies by instance type. For more information about
   * Elastic IP addresses, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html">Elastic
   * IP Addresses</a> in the <i>Amazon EC2 User Guide</i>.</p> <p>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.</p> <p>Remapping
   * an IP address is an asynchronous operation. When you move an IP address from one
   * network interface to another, check
   * <code>network/interfaces/macs/mac/local-ipv4s</code> in the instance metadata to
   * confirm that the remapping is complete.</p> <p>You must specify either the IP
   * addresses or the IP address count in the request.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html">
   * Assigning prefixes to network interfaces</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateIpAddresses">AWS
   * API Reference</a></p>
   */
  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 <typename AssignPrivateIpAddressesRequestT = Model::AssignPrivateIpAddressesRequest>
  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 <typename AssignPrivateIpAddressesRequestT = Model::AssignPrivateIpAddressesRequest>
  void AssignPrivateIpAddressesAsync(const AssignPrivateIpAddressesRequestT& request,
                                     const AssignPrivateIpAddressesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssignPrivateIpAddresses, request, handler, context);
  }

  /**
   * <p>Assigns private IPv4 addresses to a private NAT gateway. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-working-with.html">Work
   * with NAT gateways</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateNatGatewayAddress">AWS
   * API Reference</a></p>
   */
  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 <typename AssignPrivateNatGatewayAddressRequestT = Model::AssignPrivateNatGatewayAddressRequest>
  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 <typename AssignPrivateNatGatewayAddressRequestT = Model::AssignPrivateNatGatewayAddressRequest>
  void AssignPrivateNatGatewayAddressAsync(const AssignPrivateNatGatewayAddressRequestT& request,
                                           const AssignPrivateNatGatewayAddressResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssignPrivateNatGatewayAddress, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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.</p> <p>[Subnets in
   * Wavelength Zones] You can associate an IP address from the telecommunication
   * carrier to the instance or network interface. </p> <p>You cannot associate an
   * Elastic IP address with an interface in a different network border group.</p>
   *  <p>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 <i>Elastic IP Addresses</i> section of <a
   * href="http://aws.amazon.com/ec2/pricing/">Amazon EC2 Pricing</a>.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateAddress">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateAddressRequestT = Model::AssociateAddressRequest>
  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 <typename AssociateAddressRequestT = Model::AssociateAddressRequest>
  void AssociateAddressAsync(const AssociateAddressResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const AssociateAddressRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::AssociateAddress, request, handler, context);
  }

  /**
   * <p>Initiates a request to assign billing of the unused capacity of a shared
   * Capacity Reservation to a consumer account that is consolidated under the same
   * Amazon Web Services organizations payer account. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/assign-billing.html">Billing
   * assignment for shared Amazon EC2 Capacity Reservations</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateCapacityReservationBillingOwner">AWS
   * API Reference</a></p>
   */
  virtual Model::AssociateCapacityReservationBillingOwnerOutcome AssociateCapacityReservationBillingOwner(
      const Model::AssociateCapacityReservationBillingOwnerRequest& request) const;

  /**
   * A Callable wrapper for AssociateCapacityReservationBillingOwner that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename AssociateCapacityReservationBillingOwnerRequestT = Model::AssociateCapacityReservationBillingOwnerRequest>
  Model::AssociateCapacityReservationBillingOwnerOutcomeCallable AssociateCapacityReservationBillingOwnerCallable(
      const AssociateCapacityReservationBillingOwnerRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateCapacityReservationBillingOwner, request);
  }

  /**
   * An Async wrapper for AssociateCapacityReservationBillingOwner that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename AssociateCapacityReservationBillingOwnerRequestT = Model::AssociateCapacityReservationBillingOwnerRequest>
  void AssociateCapacityReservationBillingOwnerAsync(
      const AssociateCapacityReservationBillingOwnerRequestT& request,
      const AssociateCapacityReservationBillingOwnerResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateCapacityReservationBillingOwner, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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 (<a>ModifyClientVpnEndpoint</a>)
   * and change the VPC that's associated with it.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateClientVpnTargetNetwork">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateClientVpnTargetNetworkRequestT = Model::AssociateClientVpnTargetNetworkRequest>
  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 <typename AssociateClientVpnTargetNetworkRequestT = Model::AssociateClientVpnTargetNetworkRequest>
  void AssociateClientVpnTargetNetworkAsync(const AssociateClientVpnTargetNetworkRequestT& request,
                                            const AssociateClientVpnTargetNetworkResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateClientVpnTargetNetwork, request, handler, context);
  }

  /**
   * <p>Associates a set of DHCP options (that you've previously created) with the
   * specified VPC, or associates no DHCP options with the VPC.</p> <p>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.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP
   * option sets</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateDhcpOptions">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateDhcpOptionsRequestT = Model::AssociateDhcpOptionsRequest>
  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 <typename AssociateDhcpOptionsRequestT = Model::AssociateDhcpOptionsRequest>
  void AssociateDhcpOptionsAsync(const AssociateDhcpOptionsRequestT& request, const AssociateDhcpOptionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateDhcpOptions, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave-refapp.html">Certificate
   * Manager for Nitro Enclaves</a> in the <i>Amazon Web Services Nitro Enclaves User
   * Guide</i>.</p> <p>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.</p> <p>To enable the IAM role to
   * access the Amazon S3 object, you must grant it permission to call
   * <code>s3:GetObject</code> 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
   * <code>kms:Decrypt</code> on the KMS key returned by the command. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave-refapp.html#add-policy">
   * Grant the role permission to access the certificate and encryption key</a> in
   * the <i>Amazon Web Services Nitro Enclaves User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateEnclaveCertificateIamRole">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateEnclaveCertificateIamRoleRequestT = Model::AssociateEnclaveCertificateIamRoleRequest>
  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 <typename AssociateEnclaveCertificateIamRoleRequestT = Model::AssociateEnclaveCertificateIamRoleRequest>
  void AssociateEnclaveCertificateIamRoleAsync(const AssociateEnclaveCertificateIamRoleRequestT& request,
                                               const AssociateEnclaveCertificateIamRoleResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateEnclaveCertificateIamRole, request, handler, context);
  }

  /**
   * <p>Associates an IAM instance profile with a running or stopped instance. You
   * cannot associate more than one IAM instance profile with an
   * instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIamInstanceProfile">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateIamInstanceProfileRequestT = Model::AssociateIamInstanceProfileRequest>
  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 <typename AssociateIamInstanceProfileRequestT = Model::AssociateIamInstanceProfileRequest>
  void AssociateIamInstanceProfileAsync(const AssociateIamInstanceProfileRequestT& request,
                                        const AssociateIamInstanceProfileResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateIamInstanceProfile, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
   * event windows for scheduled events</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateInstanceEventWindow">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateInstanceEventWindowRequestT = Model::AssociateInstanceEventWindowRequest>
  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 <typename AssociateInstanceEventWindowRequestT = Model::AssociateInstanceEventWindowRequest>
  void AssociateInstanceEventWindowAsync(const AssociateInstanceEventWindowRequestT& request,
                                         const AssociateInstanceEventWindowResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateInstanceEventWindow, request, handler, context);
  }

  /**
   * <p>Associates your Autonomous System Number (ASN) with a BYOIP CIDR that you own
   * in the same Amazon Web Services Region. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoasn.html">Tutorial:
   * Bring your ASN to IPAM</a> in the <i>Amazon VPC IPAM guide</i>.</p> <p>After the
   * association succeeds, the ASN is eligible for advertisement. You can view the
   * association with <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeByoipCidrs.html">DescribeByoipCidrs</a>.
   * You can advertise the CIDR with <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AdvertiseByoipCidr.html">AdvertiseByoipCidr</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIpamByoasn">AWS
   * API Reference</a></p>
   */
  virtual Model::AssociateIpamByoasnOutcome AssociateIpamByoasn(const Model::AssociateIpamByoasnRequest& request) const;

  /**
   * A Callable wrapper for AssociateIpamByoasn that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AssociateIpamByoasnRequestT = Model::AssociateIpamByoasnRequest>
  Model::AssociateIpamByoasnOutcomeCallable AssociateIpamByoasnCallable(const AssociateIpamByoasnRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateIpamByoasn, request);
  }

  /**
   * An Async wrapper for AssociateIpamByoasn that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename AssociateIpamByoasnRequestT = Model::AssociateIpamByoasnRequest>
  void AssociateIpamByoasnAsync(const AssociateIpamByoasnRequestT& request, const AssociateIpamByoasnResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateIpamByoasn, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIpamResourceDiscovery">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateIpamResourceDiscoveryRequestT = Model::AssociateIpamResourceDiscoveryRequest>
  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 <typename AssociateIpamResourceDiscoveryRequestT = Model::AssociateIpamResourceDiscoveryRequest>
  void AssociateIpamResourceDiscoveryAsync(const AssociateIpamResourceDiscoveryRequestT& request,
                                           const AssociateIpamResourceDiscoveryResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateIpamResourceDiscovery, request, handler, context);
  }

  /**
   * <p>Associates Elastic IP addresses (EIPs) and private IPv4 addresses with a
   * public NAT gateway. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-working-with.html">Work
   * with NAT gateways</a> in the <i>Amazon VPC User Guide</i>.</p> <p>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
   * <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html#vpc-limits-eips">Elastic
   * IP address quotas</a> in the <i>Amazon VPC User Guide</i>.</p>
   * <p>When you associate an EIP or secondary EIPs with a public NAT gateway, the
   * network border group of the EIPs must match the network border group of the
   * Availability Zone (AZ) that the public NAT gateway is in. If it's not the same,
   * the EIP will fail to associate. You can see the network border group for the
   * subnet's AZ by viewing the details of the subnet. Similarly, you can view the
   * network border group of an EIP by viewing the details of the EIP address. For
   * more information about network border groups and EIPs, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithEIPs.html">Allocate
   * an Elastic IP address</a> in the <i>Amazon VPC User Guide</i>. </p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateNatGatewayAddress">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateNatGatewayAddressRequestT = Model::AssociateNatGatewayAddressRequest>
  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 <typename AssociateNatGatewayAddressRequestT = Model::AssociateNatGatewayAddressRequest>
  void AssociateNatGatewayAddressAsync(const AssociateNatGatewayAddressRequestT& request,
                                       const AssociateNatGatewayAddressResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateNatGatewayAddress, request, handler, context);
  }

  /**
   * <p>Associates a route server with a VPC to enable dynamic route updates.</p>
   * <p>A route server association is the connection established between a route
   * server and a VPC.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateRouteServer">AWS
   * API Reference</a></p>
   */
  virtual Model::AssociateRouteServerOutcome AssociateRouteServer(const Model::AssociateRouteServerRequest& request) const;

  /**
   * A Callable wrapper for AssociateRouteServer that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AssociateRouteServerRequestT = Model::AssociateRouteServerRequest>
  Model::AssociateRouteServerOutcomeCallable AssociateRouteServerCallable(const AssociateRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateRouteServer, request);
  }

  /**
   * An Async wrapper for AssociateRouteServer that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename AssociateRouteServerRequestT = Model::AssociateRouteServerRequest>
  void AssociateRouteServerAsync(const AssociateRouteServerRequestT& request, const AssociateRouteServerResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateRouteServer, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
   * tables</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateRouteTableRequestT = Model::AssociateRouteTableRequest>
  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 <typename AssociateRouteTableRequestT = Model::AssociateRouteTableRequest>
  void AssociateRouteTableAsync(const AssociateRouteTableRequestT& request, const AssociateRouteTableResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateRouteTable, request, handler, context);
  }

  /**
   * <p>Associates a security group with another VPC in the same Region. This enables
   * you to use the same security group with network interfaces and instances in the
   * specified VPC.</p>  <ul> <li> <p>The VPC you want to associate the
   * security group with must be in the same Region.</p> </li> <li> <p>You can
   * associate the security group with another VPC if your account owns the VPC or if
   * the VPC was shared with you.</p> </li> <li> <p>You must own the security
   * group.</p> </li> <li> <p>You cannot use this feature with default security
   * groups.</p> </li> <li> <p>You cannot use this feature with the default VPC.</p>
   * </li> </ul> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateSecurityGroupVpc">AWS
   * API Reference</a></p>
   */
  virtual Model::AssociateSecurityGroupVpcOutcome AssociateSecurityGroupVpc(const Model::AssociateSecurityGroupVpcRequest& request) const;

  /**
   * A Callable wrapper for AssociateSecurityGroupVpc that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename AssociateSecurityGroupVpcRequestT = Model::AssociateSecurityGroupVpcRequest>
  Model::AssociateSecurityGroupVpcOutcomeCallable AssociateSecurityGroupVpcCallable(
      const AssociateSecurityGroupVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateSecurityGroupVpc, request);
  }

  /**
   * An Async wrapper for AssociateSecurityGroupVpc that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename AssociateSecurityGroupVpcRequestT = Model::AssociateSecurityGroupVpcRequest>
  void AssociateSecurityGroupVpcAsync(const AssociateSecurityGroupVpcRequestT& request,
                                      const AssociateSecurityGroupVpcResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateSecurityGroupVpc, request, handler, context);
  }

  /**
   * <p>Associates a CIDR block with your subnet. You can only associate a single
   * IPv6 CIDR block with your subnet.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateSubnetCidrBlock">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateSubnetCidrBlockRequestT = Model::AssociateSubnetCidrBlockRequest>
  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 <typename AssociateSubnetCidrBlockRequestT = Model::AssociateSubnetCidrBlockRequest>
  void AssociateSubnetCidrBlockAsync(const AssociateSubnetCidrBlockRequestT& request,
                                     const AssociateSubnetCidrBlockResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateSubnetCidrBlock, request, handler, context);
  }

  /**
   * <p>Associates the specified subnets and transit gateway attachments with the
   * specified transit gateway multicast domain.</p> <p>The transit gateway
   * attachment must be in the available state before you can add a resource. Use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeTransitGatewayAttachments.html">DescribeTransitGatewayAttachments</a>
   * to see the state of the attachment.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayMulticastDomain">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateTransitGatewayMulticastDomainRequestT = Model::AssociateTransitGatewayMulticastDomainRequest>
  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 <typename AssociateTransitGatewayMulticastDomainRequestT = Model::AssociateTransitGatewayMulticastDomainRequest>
  void AssociateTransitGatewayMulticastDomainAsync(const AssociateTransitGatewayMulticastDomainRequestT& request,
                                                   const AssociateTransitGatewayMulticastDomainResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateTransitGatewayMulticastDomain, request, handler, context);
  }

  /**
   * <p>Associates the specified transit gateway attachment with a transit gateway
   * policy table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayPolicyTable">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateTransitGatewayPolicyTableRequestT = Model::AssociateTransitGatewayPolicyTableRequest>
  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 <typename AssociateTransitGatewayPolicyTableRequestT = Model::AssociateTransitGatewayPolicyTableRequest>
  void AssociateTransitGatewayPolicyTableAsync(const AssociateTransitGatewayPolicyTableRequestT& request,
                                               const AssociateTransitGatewayPolicyTableResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateTransitGatewayPolicyTable, request, handler, context);
  }

  /**
   * <p>Associates the specified attachment with the specified transit gateway route
   * table. You can associate only one route table with an attachment.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateTransitGatewayRouteTableRequestT = Model::AssociateTransitGatewayRouteTableRequest>
  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 <typename AssociateTransitGatewayRouteTableRequestT = Model::AssociateTransitGatewayRouteTableRequest>
  void AssociateTransitGatewayRouteTableAsync(const AssociateTransitGatewayRouteTableRequestT& request,
                                              const AssociateTransitGatewayRouteTableResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateTransitGatewayRouteTable, request, handler, context);
  }

  /**
   * <p>Associates a branch network interface with a trunk network interface.</p>
   * <p>Before you create the association, use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html">CreateNetworkInterface</a>
   * command and set the interface type to <code>trunk</code>. You must also create a
   * network interface for each branch network interface that you want to associate
   * with the trunk network interface.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTrunkInterface">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateTrunkInterfaceRequestT = Model::AssociateTrunkInterfaceRequest>
  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 <typename AssociateTrunkInterfaceRequestT = Model::AssociateTrunkInterfaceRequest>
  void AssociateTrunkInterfaceAsync(const AssociateTrunkInterfaceRequestT& request,
                                    const AssociateTrunkInterfaceResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateTrunkInterface, request, handler, context);
  }

  /**
   * <p>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 (<a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">BYOIP</a>).</p>
   * <p>You must specify one of the following in the request: an IPv4 CIDR block, an
   * IPv6 pool, or an Amazon-provided IPv6 CIDR block.</p> <p>For more information
   * about associating CIDR blocks with your VPC and applicable restrictions, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-ip-addressing.html">IP
   * addressing for your VPCs and subnets</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateVpcCidrBlock">AWS
   * API Reference</a></p>
   */
  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 <typename AssociateVpcCidrBlockRequestT = Model::AssociateVpcCidrBlockRequest>
  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 <typename AssociateVpcCidrBlockRequestT = Model::AssociateVpcCidrBlockRequest>
  void AssociateVpcCidrBlockAsync(const AssociateVpcCidrBlockRequestT& request, const AssociateVpcCidrBlockResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AssociateVpcCidrBlock, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>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 <code>running</code> 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.</p> <p>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.</p> <p>Linking your instance to a VPC is sometimes referred to as
   * <i>attaching</i> your instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachClassicLinkVpc">AWS
   * API Reference</a></p>
   */
  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 <typename AttachClassicLinkVpcRequestT = Model::AttachClassicLinkVpcRequest>
  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 <typename AttachClassicLinkVpcRequestT = Model::AttachClassicLinkVpcRequest>
  void AttachClassicLinkVpcAsync(const AttachClassicLinkVpcRequestT& request, const AttachClassicLinkVpcResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AttachClassicLinkVpc, request, handler, context);
  }

  /**
   * <p>Attaches an internet gateway or a virtual private gateway to a VPC, enabling
   * connectivity between the internet and the VPC. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html">Internet
   * gateways</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachInternetGateway">AWS
   * API Reference</a></p>
   */
  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 <typename AttachInternetGatewayRequestT = Model::AttachInternetGatewayRequest>
  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 <typename AttachInternetGatewayRequestT = Model::AttachInternetGatewayRequest>
  void AttachInternetGatewayAsync(const AttachInternetGatewayRequestT& request, const AttachInternetGatewayResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AttachInternetGateway, request, handler, context);
  }

  /**
   * <p>Attaches a network interface to an instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachNetworkInterface">AWS
   * API Reference</a></p>
   */
  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 <typename AttachNetworkInterfaceRequestT = Model::AttachNetworkInterfaceRequest>
  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 <typename AttachNetworkInterfaceRequestT = Model::AttachNetworkInterfaceRequest>
  void AttachNetworkInterfaceAsync(const AttachNetworkInterfaceRequestT& request,
                                   const AttachNetworkInterfaceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AttachNetworkInterface, request, handler, context);
  }

  /**
   * <p>Attaches the specified Amazon Web Services Verified Access trust provider to
   * the specified Amazon Web Services Verified Access instance.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVerifiedAccessTrustProvider">AWS
   * API Reference</a></p>
   */
  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 <typename AttachVerifiedAccessTrustProviderRequestT = Model::AttachVerifiedAccessTrustProviderRequest>
  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 <typename AttachVerifiedAccessTrustProviderRequestT = Model::AttachVerifiedAccessTrustProviderRequest>
  void AttachVerifiedAccessTrustProviderAsync(const AttachVerifiedAccessTrustProviderRequestT& request,
                                              const AttachVerifiedAccessTrustProviderResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AttachVerifiedAccessTrustProvider, request, handler, context);
  }

  /**
   * <p>Attaches an Amazon EBS volume to a <code>running</code> or
   * <code>stopped</code> instance, and exposes it to the instance with the specified
   * device name.</p>  <p>The maximum number of Amazon EBS volumes that you can
   * attach to an instance depends on the instance type. If you exceed the volume
   * attachment limit for an instance type, the attachment request fails with the
   * <code>AttachmentLimitExceeded</code> error. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/volume_limits.html">Instance
   * volume limits</a>.</p>  <p>After you attach an EBS volume, you must make
   * it available for use. For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-using-volumes.html">Make
   * an EBS volume available for use</a>.</p> <p>If a volume has an Amazon Web
   * Services Marketplace product code:</p> <ul> <li> <p>The volume can be attached
   * only to a stopped instance.</p> </li> <li> <p>Amazon Web Services Marketplace
   * product codes are copied from the volume to the instance.</p> </li> <li> <p>You
   * must be subscribed to the product.</p> </li> <li> <p>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.</p> </li> </ul> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-attaching-volume.html">Attach
   * an Amazon EBS volume to an instance</a> in the <i>Amazon EBS User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVolume">AWS
   * API Reference</a></p>
   */
  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 <typename AttachVolumeRequestT = Model::AttachVolumeRequest>
  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 <typename AttachVolumeRequestT = Model::AttachVolumeRequest>
  void AttachVolumeAsync(const AttachVolumeRequestT& request, const AttachVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AttachVolume, request, handler, context);
  }

  /**
   * <p>Attaches an available virtual private gateway to a VPC. You can attach one
   * virtual private gateway to one VPC at a time.</p> <p>For more information, see
   * <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web
   * Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVpnGateway">AWS
   * API Reference</a></p>
   */
  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 <typename AttachVpnGatewayRequestT = Model::AttachVpnGatewayRequest>
  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 <typename AttachVpnGatewayRequestT = Model::AttachVpnGatewayRequest>
  void AttachVpnGatewayAsync(const AttachVpnGatewayRequestT& request, const AttachVpnGatewayResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AttachVpnGateway, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeClientVpnIngress">AWS
   * API Reference</a></p>
   */
  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 <typename AuthorizeClientVpnIngressRequestT = Model::AuthorizeClientVpnIngressRequest>
  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 <typename AuthorizeClientVpnIngressRequestT = Model::AuthorizeClientVpnIngressRequest>
  void AuthorizeClientVpnIngressAsync(const AuthorizeClientVpnIngressRequestT& request,
                                      const AuthorizeClientVpnIngressResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AuthorizeClientVpnIngress, request, handler, context);
  }

  /**
   * <p>Adds the specified outbound (egress) rules to a security group.</p> <p>An
   * outbound rule permits instances to send traffic to the specified IPv4 or IPv6
   * address ranges, the IP address ranges specified by a prefix list, or the
   * instances that are associated with a source security group. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html">Security
   * group rules</a>.</p> <p>You must specify exactly one of the following
   * destinations: an IPv4 or IPv6 address range, a prefix list, or a security group.
   * You must specify a protocol for each rule (for example, TCP). If the protocol is
   * TCP or UDP, you must also specify a port or port range. If the protocol is ICMP
   * or ICMPv6, you must also specify the ICMP type and code.</p> <p>Rule changes are
   * propagated to instances associated with the security group as quickly as
   * possible. However, a small delay might occur.</p> <p>For examples of rules that
   * you can add to security groups for specific access scenarios, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html">Security
   * group rules for different use cases</a> in the <i>Amazon EC2 User Guide</i>.</p>
   * <p>For information about security group quotas, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon
   * VPC quotas</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupEgress">AWS
   * API Reference</a></p>
   */
  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 <typename AuthorizeSecurityGroupEgressRequestT = Model::AuthorizeSecurityGroupEgressRequest>
  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 <typename AuthorizeSecurityGroupEgressRequestT = Model::AuthorizeSecurityGroupEgressRequest>
  void AuthorizeSecurityGroupEgressAsync(const AuthorizeSecurityGroupEgressRequestT& request,
                                         const AuthorizeSecurityGroupEgressResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AuthorizeSecurityGroupEgress, request, handler, context);
  }

  /**
   * <p>Adds the specified inbound (ingress) rules to a security group.</p> <p>An
   * inbound rule permits instances to receive traffic from the specified IPv4 or
   * IPv6 address range, the IP address ranges that are specified by a prefix list,
   * or the instances that are associated with a destination security group. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html">Security
   * group rules</a>.</p> <p>You must specify exactly one of the following sources:
   * an IPv4 or IPv6 address range, a prefix list, or a security group. You must
   * specify a protocol for each rule (for example, TCP). If the protocol is TCP or
   * UDP, you must also specify a port or port range. If the protocol is ICMP or
   * ICMPv6, you must also specify the ICMP/ICMPv6 type and code.</p> <p>Rule changes
   * are propagated to instances associated with the security group as quickly as
   * possible. However, a small delay might occur.</p> <p>For examples of rules that
   * you can add to security groups for specific access scenarios, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules-reference.html">Security
   * group rules for different use cases</a> in the <i>Amazon EC2 User Guide</i>.</p>
   * <p>For more information about security group quotas, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon
   * VPC quotas</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupIngress">AWS
   * API Reference</a></p>
   */
  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 <typename AuthorizeSecurityGroupIngressRequestT = Model::AuthorizeSecurityGroupIngressRequest>
  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 <typename AuthorizeSecurityGroupIngressRequestT = Model::AuthorizeSecurityGroupIngressRequest>
  void AuthorizeSecurityGroupIngressAsync(const AuthorizeSecurityGroupIngressResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const AuthorizeSecurityGroupIngressRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::AuthorizeSecurityGroupIngress, request, handler, context);
  }

  /**
   * <p>Bundles an Amazon instance store-backed Windows instance.</p> <p>During
   * bundling, only the root device volume (C:\) is bundled. Data on other instance
   * store volumes is not preserved.</p>  <p>This action is not applicable for
   * Linux/Unix instances or Windows instances that are backed by Amazon EBS.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/BundleInstance">AWS
   * API Reference</a></p>
   */
  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 <typename BundleInstanceRequestT = Model::BundleInstanceRequest>
  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 <typename BundleInstanceRequestT = Model::BundleInstanceRequest>
  void BundleInstanceAsync(const BundleInstanceRequestT& request, const BundleInstanceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::BundleInstance, request, handler, context);
  }

  /**
   * <p>Cancels a bundling operation for an instance store-backed Windows
   * instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelBundleTask">AWS
   * API Reference</a></p>
   */
  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 <typename CancelBundleTaskRequestT = Model::CancelBundleTaskRequest>
  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 <typename CancelBundleTaskRequestT = Model::CancelBundleTaskRequest>
  void CancelBundleTaskAsync(const CancelBundleTaskRequestT& request, const CancelBundleTaskResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelBundleTask, request, handler, context);
  }

  /**
   * <p>Cancels the specified Capacity Reservation, releases the reserved capacity,
   * and changes the Capacity Reservation's state to <code>cancelled</code>.</p>
   * <p>You can cancel a Capacity Reservation that is in the following states:</p>
   * <ul> <li> <p> <code>assessing</code> </p> </li> <li> <p> <code>active</code> and
   * there is no commitment duration or the commitment duration has elapsed. You
   * can't cancel a future-dated Capacity Reservation during the commitment
   * duration.</p> </li> </ul>  <p>You can't modify or cancel a Capacity Block.
   * For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-capacity-blocks.html">Capacity
   * Blocks for ML</a>.</p>  <p>If a future-dated Capacity Reservation enters
   * the <code>delayed</code> state, the commitment duration is waived, and you can
   * cancel it as soon as it enters the <code>active</code> state.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelCapacityReservation">AWS
   * API Reference</a></p>
   */
  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 <typename CancelCapacityReservationRequestT = Model::CancelCapacityReservationRequest>
  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 <typename CancelCapacityReservationRequestT = Model::CancelCapacityReservationRequest>
  void CancelCapacityReservationAsync(const CancelCapacityReservationRequestT& request,
                                      const CancelCapacityReservationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelCapacityReservation, request, handler, context);
  }

  /**
   * <p>Cancels one or more Capacity Reservation Fleets. When you cancel a Capacity
   * Reservation Fleet, the following happens:</p> <ul> <li> <p>The Capacity
   * Reservation Fleet's status changes to <code>cancelled</code>.</p> </li> <li>
   * <p>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.</p> </li> <li> <p>The Fleet stops creating
   * new Capacity Reservations.</p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelCapacityReservationFleets">AWS
   * API Reference</a></p>
   */
  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 <typename CancelCapacityReservationFleetsRequestT = Model::CancelCapacityReservationFleetsRequest>
  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 <typename CancelCapacityReservationFleetsRequestT = Model::CancelCapacityReservationFleetsRequest>
  void CancelCapacityReservationFleetsAsync(const CancelCapacityReservationFleetsRequestT& request,
                                            const CancelCapacityReservationFleetsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelCapacityReservationFleets, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelConversionTask">AWS
   * API Reference</a></p>
   */
  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 <typename CancelConversionTaskRequestT = Model::CancelConversionTaskRequest>
  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 <typename CancelConversionTaskRequestT = Model::CancelConversionTaskRequest>
  void CancelConversionTaskAsync(const CancelConversionTaskRequestT& request, const CancelConversionTaskResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelConversionTask, request, handler, context);
  }

  /**
   * <p>Cancels the generation of an account status report.</p> <p>You can only
   * cancel a report while it has the <code>running</code> status. Reports with other
   * statuses (<code>complete</code>, <code>cancelled</code>, or <code>error</code>)
   * can't be canceled.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_declarative_status-report.html">Generating
   * the account status report for declarative policies</a> in the <i>Amazon Web
   * Services Organizations User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelDeclarativePoliciesReport">AWS
   * API Reference</a></p>
   */
  virtual Model::CancelDeclarativePoliciesReportOutcome CancelDeclarativePoliciesReport(
      const Model::CancelDeclarativePoliciesReportRequest& request) const;

  /**
   * A Callable wrapper for CancelDeclarativePoliciesReport that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CancelDeclarativePoliciesReportRequestT = Model::CancelDeclarativePoliciesReportRequest>
  Model::CancelDeclarativePoliciesReportOutcomeCallable CancelDeclarativePoliciesReportCallable(
      const CancelDeclarativePoliciesReportRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelDeclarativePoliciesReport, request);
  }

  /**
   * An Async wrapper for CancelDeclarativePoliciesReport that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename CancelDeclarativePoliciesReportRequestT = Model::CancelDeclarativePoliciesReportRequest>
  void CancelDeclarativePoliciesReportAsync(const CancelDeclarativePoliciesReportRequestT& request,
                                            const CancelDeclarativePoliciesReportResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelDeclarativePoliciesReport, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelExportTask">AWS
   * API Reference</a></p>
   */
  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 <typename CancelExportTaskRequestT = Model::CancelExportTaskRequest>
  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 <typename CancelExportTaskRequestT = Model::CancelExportTaskRequest>
  void CancelExportTaskAsync(const CancelExportTaskRequestT& request, const CancelExportTaskResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelExportTask, request, handler, context);
  }

  /**
   * <p>Removes your Amazon Web Services account from the launch permissions for the
   * specified AMI. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cancel-sharing-an-AMI.html">Cancel
   * having an AMI shared with your Amazon Web Services account</a> in the <i>Amazon
   * EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImageLaunchPermission">AWS
   * API Reference</a></p>
   */
  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 <typename CancelImageLaunchPermissionRequestT = Model::CancelImageLaunchPermissionRequest>
  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 <typename CancelImageLaunchPermissionRequestT = Model::CancelImageLaunchPermissionRequest>
  void CancelImageLaunchPermissionAsync(const CancelImageLaunchPermissionRequestT& request,
                                        const CancelImageLaunchPermissionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelImageLaunchPermission, request, handler, context);
  }

  /**
   * <p>Cancels an in-process import virtual machine or import snapshot
   * task.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImportTask">AWS
   * API Reference</a></p>
   */
  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 <typename CancelImportTaskRequestT = Model::CancelImportTaskRequest>
  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 <typename CancelImportTaskRequestT = Model::CancelImportTaskRequest>
  void CancelImportTaskAsync(const CancelImportTaskResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const CancelImportTaskRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CancelImportTask, request, handler, context);
  }

  /**
   * <p>Cancels the specified Reserved Instance listing in the Reserved Instance
   * Marketplace.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Sell
   * in the Reserved Instance Marketplace</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelReservedInstancesListing">AWS
   * API Reference</a></p>
   */
  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 <typename CancelReservedInstancesListingRequestT = Model::CancelReservedInstancesListingRequest>
  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 <typename CancelReservedInstancesListingRequestT = Model::CancelReservedInstancesListingRequest>
  void CancelReservedInstancesListingAsync(const CancelReservedInstancesListingRequestT& request,
                                           const CancelReservedInstancesListingResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelReservedInstancesListing, request, handler, context);
  }

  /**
   * <p>Cancels the specified Spot Fleet requests.</p> <p>After you cancel a Spot
   * Fleet request, the Spot Fleet launches no new instances.</p> <p>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
   * <code>cancelled_terminating</code> state. Otherwise, the Spot Fleet request
   * enters the <code>cancelled_running</code> state and the instances continue to
   * run until they are interrupted or you terminate them manually.</p>
   * <p> <b>Terminating an instance is permanent and irreversible.</b> </p> <p>After
   * you terminate an instance, you can no longer connect to it, and it can't be
   * recovered. All attached Amazon EBS volumes that are configured to be deleted on
   * termination are also permanently deleted and can't be recovered. All data stored
   * on instance store volumes is permanently lost. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-ec2-instance-termination-works.html">
   * How instance termination works</a>.</p> <p>Before you terminate an instance,
   * ensure that you have backed up all data that you need to retain after the
   * termination to persistent storage.</p>  <p class="title">
   * <b>Restrictions</b> </p> <ul> <li> <p>You can delete up to 100 fleets in a
   * single request. If you exceed the specified number, no fleets are deleted.</p>
   * </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotFleetRequests">AWS
   * API Reference</a></p>
   */
  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 <typename CancelSpotFleetRequestsRequestT = Model::CancelSpotFleetRequestsRequest>
  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 <typename CancelSpotFleetRequestsRequestT = Model::CancelSpotFleetRequestsRequest>
  void CancelSpotFleetRequestsAsync(const CancelSpotFleetRequestsRequestT& request,
                                    const CancelSpotFleetRequestsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelSpotFleetRequests, request, handler, context);
  }

  /**
   * <p>Cancels one or more Spot Instance requests.</p>  <p>Canceling a
   * Spot Instance request does not terminate running Spot Instances associated with
   * the request.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotInstanceRequests">AWS
   * API Reference</a></p>
   */
  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 <typename CancelSpotInstanceRequestsRequestT = Model::CancelSpotInstanceRequestsRequest>
  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 <typename CancelSpotInstanceRequestsRequestT = Model::CancelSpotInstanceRequestsRequest>
  void CancelSpotInstanceRequestsAsync(const CancelSpotInstanceRequestsRequestT& request,
                                       const CancelSpotInstanceRequestsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CancelSpotInstanceRequests, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ConfirmProductInstance">AWS
   * API Reference</a></p>
   */
  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 <typename ConfirmProductInstanceRequestT = Model::ConfirmProductInstanceRequest>
  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 <typename ConfirmProductInstanceRequestT = Model::ConfirmProductInstanceRequest>
  void ConfirmProductInstanceAsync(const ConfirmProductInstanceRequestT& request,
                                   const ConfirmProductInstanceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ConfirmProductInstance, request, handler, context);
  }

  /**
   * <p>Copies the specified Amazon FPGA Image (AFI) to the current
   * Region.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyFpgaImage">AWS
   * API Reference</a></p>
   */
  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 <typename CopyFpgaImageRequestT = Model::CopyFpgaImageRequest>
  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 <typename CopyFpgaImageRequestT = Model::CopyFpgaImageRequest>
  void CopyFpgaImageAsync(const CopyFpgaImageRequestT& request, const CopyFpgaImageResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CopyFpgaImage, request, handler, context);
  }

  /**
   * <p>Initiates an AMI copy operation. You must specify the source AMI ID and both
   * the source and destination locations. The copy operation must be initiated in
   * the destination Region.</p> <p class="title"> <b>CopyImage supports the
   * following source to destination copies:</b> </p> <ul> <li> <p>Region to
   * Region</p> </li> <li> <p>Region to Outpost</p> </li> <li> <p>Parent Region to
   * Local Zone</p> </li> <li> <p>Local Zone to parent Region</p> </li> <li>
   * <p>Between Local Zones with the same parent Region (only supported for certain
   * Local Zones)</p> </li> </ul> <p class="title"> <b>CopyImage does not support the
   * following source to destination copies:</b> </p> <ul> <li> <p>Local Zone to
   * non-parent Regions</p> </li> <li> <p>Between Local Zones with different parent
   * Regions</p> </li> <li> <p>Local Zone to Outpost</p> </li> <li> <p>Outpost to
   * Local Zone</p> </li> <li> <p>Outpost to Region</p> </li> <li> <p>Between
   * Outposts</p> </li> <li> <p>Within same Outpost</p> </li> <li> <p>Cross-partition
   * copies (use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateStoreImageTask.html">CreateStoreImageTask</a>
   * instead)</p> </li> </ul> <p class="title"> <b>Destination specification</b> </p>
   * <ul> <li> <p>Region to Region: The destination Region is the Region in which you
   * initiate the copy operation.</p> </li> <li> <p>Region to Outpost: Specify the
   * destination using the <code>DestinationOutpostArn</code> parameter (the ARN of
   * the Outpost)</p> </li> <li> <p>Region to Local Zone, and Local Zone to Local
   * Zone copies: Specify the destination using the
   * <code>DestinationAvailabilityZone</code> parameter (the name of the destination
   * Local Zone) or <code>DestinationAvailabilityZoneId</code> parameter (the ID of
   * the destination Local Zone).</p> </li> </ul> <p class="title"> <b>Snapshot
   * encryption</b> </p> <ul> <li> <p>Region to Outpost: Backing snapshots copied to
   * an Outpost are encrypted by default using the default encryption key for the
   * Region or the key that you specify. Outposts do not support unencrypted
   * snapshots.</p> </li> <li> <p>Region to Local Zone, and Local Zone to Local Zone:
   * Not all Local Zones require encrypted snapshots. In Local Zones that require
   * encrypted snapshots, backing snapshots are automatically encrypted during copy.
   * In Local Zones where encryption is not required, snapshots retain their original
   * encryption state (encrypted or unencrypted) by default.</p> </li> </ul> <p>For
   * more information, including the required permissions for copying an AMI, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html">Copy
   * an Amazon EC2 AMI</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyImage">AWS API
   * Reference</a></p>
   */
  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 <typename CopyImageRequestT = Model::CopyImageRequest>
  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 <typename CopyImageRequestT = Model::CopyImageRequest>
  void CopyImageAsync(const CopyImageRequestT& request, const CopyImageResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CopyImage, request, handler, context);
  }

  /**
   * <p>Creates an exact copy of an Amazon EBS snapshot.</p> <p>The location of the
   * source snapshot determines whether you can copy it or not, and the allowed
   * destinations for the snapshot copy.</p> <ul> <li> <p>If the source snapshot is
   * in a Region, you can copy it within that Region, to another Region, to an
   * Outpost associated with that Region, or to a Local Zone in that Region.</p>
   * </li> <li> <p>If the source snapshot is in a Local Zone, you can copy it within
   * that Local Zone, to another Local Zone in the same zone group, or to the parent
   * Region of the Local Zone.</p> </li> <li> <p>If the source snapshot is on an
   * Outpost, you can't copy it.</p> </li> </ul> <p>When copying snapshots to a
   * Region, the encryption outcome for the snapshot copy depends on the Amazon EBS
   * encryption by default setting for the destination Region, the encryption status
   * of the source snapshot, and the encryption parameters you specify in the
   * request. For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-copy-snapshot.html#creating-encrypted-snapshots">
   * Encryption and snapshot copying</a>.</p> <p>Snapshots copied to an Outpost must
   * be encrypted. Unencrypted snapshots are not supported on Outposts. For more
   * information, <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/snapshots-outposts.html#considerations">
   * Amazon EBS local snapshots on Outposts</a>.</p>  <p>Snapshots copies have
   * an arbitrary source volume ID. Do not use this volume ID for any purpose.</p>
   *  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-copy-snapshot.html">Copy
   * an Amazon EBS snapshot</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopySnapshot">AWS
   * API Reference</a></p>
   */
  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 <typename CopySnapshotRequestT = Model::CopySnapshotRequest>
  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 <typename CopySnapshotRequestT = Model::CopySnapshotRequest>
  void CopySnapshotAsync(const CopySnapshotRequestT& request, const CopySnapshotResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CopySnapshot, request, handler, context);
  }

  /**
   * <p>Creates a crash-consistent, point-in-time copy of an existing Amazon EBS
   * volume within the same Availability Zone. The volume copy can be attached to an
   * Amazon EC2 instance once it reaches the <code>available</code> state. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-copying-volume.html">Copy
   * an Amazon EBS volume</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyVolumes">AWS API
   * Reference</a></p>
   */
  virtual Model::CopyVolumesOutcome CopyVolumes(const Model::CopyVolumesRequest& request) const;

  /**
   * A Callable wrapper for CopyVolumes that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename CopyVolumesRequestT = Model::CopyVolumesRequest>
  Model::CopyVolumesOutcomeCallable CopyVolumesCallable(const CopyVolumesRequestT& request) const {
    return SubmitCallable(&EC2Client::CopyVolumes, request);
  }

  /**
   * An Async wrapper for CopyVolumes that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename CopyVolumesRequestT = Model::CopyVolumesRequest>
  void CopyVolumesAsync(const CopyVolumesRequestT& request, const CopyVolumesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CopyVolumes, request, handler, context);
  }

  /**
   * <p> Creates a new data export configuration for EC2 Capacity Manager. This
   * allows you to automatically export capacity usage data to an S3 bucket on a
   * scheduled basis. The exported data includes metrics for On-Demand, Spot, and
   * Capacity Reservations usage across your organization. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityManagerDataExport">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateCapacityManagerDataExportOutcome CreateCapacityManagerDataExport(
      const Model::CreateCapacityManagerDataExportRequest& request) const;

  /**
   * A Callable wrapper for CreateCapacityManagerDataExport that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreateCapacityManagerDataExportRequestT = Model::CreateCapacityManagerDataExportRequest>
  Model::CreateCapacityManagerDataExportOutcomeCallable CreateCapacityManagerDataExportCallable(
      const CreateCapacityManagerDataExportRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCapacityManagerDataExport, request);
  }

  /**
   * An Async wrapper for CreateCapacityManagerDataExport that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename CreateCapacityManagerDataExportRequestT = Model::CreateCapacityManagerDataExportRequest>
  void CreateCapacityManagerDataExportAsync(const CreateCapacityManagerDataExportRequestT& request,
                                            const CreateCapacityManagerDataExportResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateCapacityManagerDataExport, request, handler, context);
  }

  /**
   * <p>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.</p> <p>You can create a Capacity
   * Reservation at any time, and you can choose when it starts. You can create a
   * Capacity Reservation for immediate use or you can request a Capacity Reservation
   * for a future date.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-capacity-reservations.html">
   * Reserve compute capacity with On-Demand Capacity Reservations</a> in the
   * <i>Amazon EC2 User Guide</i>.</p> <p>Your request to create a Capacity
   * Reservation could fail if:</p> <ul> <li> <p>Amazon EC2 does not have sufficient
   * capacity. In this case, try again at a later time, try in a different
   * Availability Zone, or request a smaller Capacity Reservation. If your workload
   * is flexible across instance types and sizes, try with different instance
   * attributes.</p> </li> <li> <p>The requested quantity exceeds your On-Demand
   * Instance quota. In this case, increase your On-Demand Instance quota for the
   * requested instance type and try again. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html">
   * Amazon EC2 Service Quotas</a> in the <i>Amazon EC2 User Guide</i>.</p> </li>
   * </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityReservation">AWS
   * API Reference</a></p>
   */
  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 <typename CreateCapacityReservationRequestT = Model::CreateCapacityReservationRequest>
  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 <typename CreateCapacityReservationRequestT = Model::CreateCapacityReservationRequest>
  void CreateCapacityReservationAsync(const CreateCapacityReservationRequestT& request,
                                      const CreateCapacityReservationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateCapacityReservation, request, handler, context);
  }

  /**
   * <p> Create a new Capacity Reservation by splitting the capacity of the source
   * Capacity Reservation. The new Capacity Reservation will have the same attributes
   * as the source Capacity Reservation except for tags. The source Capacity
   * Reservation must be <code>active</code> and owned by your Amazon Web Services
   * account. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityReservationBySplitting">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateCapacityReservationBySplittingOutcome CreateCapacityReservationBySplitting(
      const Model::CreateCapacityReservationBySplittingRequest& request) const;

  /**
   * A Callable wrapper for CreateCapacityReservationBySplitting that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename CreateCapacityReservationBySplittingRequestT = Model::CreateCapacityReservationBySplittingRequest>
  Model::CreateCapacityReservationBySplittingOutcomeCallable CreateCapacityReservationBySplittingCallable(
      const CreateCapacityReservationBySplittingRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCapacityReservationBySplitting, request);
  }

  /**
   * An Async wrapper for CreateCapacityReservationBySplitting that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename CreateCapacityReservationBySplittingRequestT = Model::CreateCapacityReservationBySplittingRequest>
  void CreateCapacityReservationBySplittingAsync(const CreateCapacityReservationBySplittingRequestT& request,
                                                 const CreateCapacityReservationBySplittingResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateCapacityReservationBySplitting, request, handler, context);
  }

  /**
   * <p>Creates a Capacity Reservation Fleet. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-cr-fleets.html#create-crfleet">Create
   * a Capacity Reservation Fleet</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityReservationFleet">AWS
   * API Reference</a></p>
   */
  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 <typename CreateCapacityReservationFleetRequestT = Model::CreateCapacityReservationFleetRequest>
  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 <typename CreateCapacityReservationFleetRequestT = Model::CreateCapacityReservationFleetRequest>
  void CreateCapacityReservationFleetAsync(const CreateCapacityReservationFleetRequestT& request,
                                           const CreateCapacityReservationFleetResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateCapacityReservationFleet, request, handler, context);
  }

  /**
   * <p>Creates a carrier gateway. For more information about carrier gateways, see
   * <a
   * href="https://docs.aws.amazon.com/wavelength/latest/developerguide/how-wavelengths-work.html#wavelength-carrier-gateway">Carrier
   * gateways</a> in the <i>Amazon Web Services Wavelength Developer
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCarrierGateway">AWS
   * API Reference</a></p>
   */
  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 <typename CreateCarrierGatewayRequestT = Model::CreateCarrierGatewayRequest>
  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 <typename CreateCarrierGatewayRequestT = Model::CreateCarrierGatewayRequest>
  void CreateCarrierGatewayAsync(const CreateCarrierGatewayRequestT& request, const CreateCarrierGatewayResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateCarrierGateway, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateClientVpnEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename CreateClientVpnEndpointRequestT = Model::CreateClientVpnEndpointRequest>
  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 <typename CreateClientVpnEndpointRequestT = Model::CreateClientVpnEndpointRequest>
  void CreateClientVpnEndpointAsync(const CreateClientVpnEndpointRequestT& request,
                                    const CreateClientVpnEndpointResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateClientVpnEndpoint, request, handler, context);
  }

  /**
   * <p>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 traﬃc to speciﬁc resources or
   * networks.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateClientVpnRoute">AWS
   * API Reference</a></p>
   */
  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 <typename CreateClientVpnRouteRequestT = Model::CreateClientVpnRouteRequest>
  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 <typename CreateClientVpnRouteRequestT = Model::CreateClientVpnRouteRequest>
  void CreateClientVpnRouteAsync(const CreateClientVpnRouteRequestT& request, const CreateClientVpnRouteResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateClientVpnRoute, request, handler, context);
  }

  /**
   * <p> Creates a range of customer-owned IP addresses. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCoipCidr">AWS
   * API Reference</a></p>
   */
  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 <typename CreateCoipCidrRequestT = Model::CreateCoipCidrRequest>
  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 <typename CreateCoipCidrRequestT = Model::CreateCoipCidrRequest>
  void CreateCoipCidrAsync(const CreateCoipCidrRequestT& request, const CreateCoipCidrResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateCoipCidr, request, handler, context);
  }

  /**
   * <p> Creates a pool of customer-owned IP (CoIP) addresses. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCoipPool">AWS
   * API Reference</a></p>
   */
  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 <typename CreateCoipPoolRequestT = Model::CreateCoipPoolRequest>
  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 <typename CreateCoipPoolRequestT = Model::CreateCoipPoolRequest>
  void CreateCoipPoolAsync(const CreateCoipPoolRequestT& request, const CreateCoipPoolResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateCoipPool, request, handler, context);
  }

  /**
   * <p>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).</p> <p>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 <a
   * href="https://docs.aws.amazon.com/vpn/latest/s2svpn/cgw-options.html">Customer
   * gateway options for your Site-to-Site VPN connection</a> in the <i>Amazon Web
   * Services Site-to-Site VPN User Guide</i>.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCustomerGateway">AWS
   * API Reference</a></p>
   */
  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 <typename CreateCustomerGatewayRequestT = Model::CreateCustomerGatewayRequest>
  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 <typename CreateCustomerGatewayRequestT = Model::CreateCustomerGatewayRequest>
  void CreateCustomerGatewayAsync(const CreateCustomerGatewayRequestT& request, const CreateCustomerGatewayResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateCustomerGateway, request, handler, context);
  }

  /**
   * <p>Creates a default subnet with a size <code>/20</code> 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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/work-with-default-vpc.html#create-default-subnet">Create
   * a default subnet</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDefaultSubnet">AWS
   * API Reference</a></p>
   */
  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 <typename CreateDefaultSubnetRequestT = Model::CreateDefaultSubnetRequest>
  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 <typename CreateDefaultSubnetRequestT = Model::CreateDefaultSubnetRequest>
  void CreateDefaultSubnetAsync(const CreateDefaultSubnetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const CreateDefaultSubnetRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateDefaultSubnet, request, handler, context);
  }

  /**
   * <p>Creates a default VPC with a size <code>/16</code> IPv4 CIDR block and a
   * default subnet in each Availability Zone. For more information about the
   * components of a default VPC, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html">Default
   * VPCs</a> in the <i>Amazon VPC User Guide</i>. You cannot specify the components
   * of the default VPC yourself.</p> <p>If you deleted your previous default VPC,
   * you can create a default VPC. You cannot have more than one default VPC per
   * Region.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDefaultVpc">AWS
   * API Reference</a></p>
   */
  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 <typename CreateDefaultVpcRequestT = Model::CreateDefaultVpcRequest>
  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 <typename CreateDefaultVpcRequestT = Model::CreateDefaultVpcRequest>
  void CreateDefaultVpcAsync(const CreateDefaultVpcResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const CreateDefaultVpcRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateDefaultVpc, request, handler, context);
  }

  /**
   * <p>Delegates ownership of the Amazon EBS root volume for an Apple silicon Mac
   * instance to an administrative user.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDelegateMacVolumeOwnershipTask">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateDelegateMacVolumeOwnershipTaskOutcome CreateDelegateMacVolumeOwnershipTask(
      const Model::CreateDelegateMacVolumeOwnershipTaskRequest& request) const;

  /**
   * A Callable wrapper for CreateDelegateMacVolumeOwnershipTask that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename CreateDelegateMacVolumeOwnershipTaskRequestT = Model::CreateDelegateMacVolumeOwnershipTaskRequest>
  Model::CreateDelegateMacVolumeOwnershipTaskOutcomeCallable CreateDelegateMacVolumeOwnershipTaskCallable(
      const CreateDelegateMacVolumeOwnershipTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateDelegateMacVolumeOwnershipTask, request);
  }

  /**
   * An Async wrapper for CreateDelegateMacVolumeOwnershipTask that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename CreateDelegateMacVolumeOwnershipTaskRequestT = Model::CreateDelegateMacVolumeOwnershipTaskRequest>
  void CreateDelegateMacVolumeOwnershipTaskAsync(const CreateDelegateMacVolumeOwnershipTaskRequestT& request,
                                                 const CreateDelegateMacVolumeOwnershipTaskResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateDelegateMacVolumeOwnershipTask, request, handler, context);
  }

  /**
   * <p>Creates a custom set of DHCP options. After you create a DHCP option set, you
   * associate it with a VPC. After you associate a DHCP option set with a VPC, all
   * existing and newly launched instances in the VPC use this set of DHCP
   * options.</p> <p>The following are the individual DHCP options you can specify.
   * For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP
   * option sets</a> in the <i>Amazon VPC User Guide</i>.</p> <ul> <li> <p>
   * <code>domain-name</code> - If you're using AmazonProvidedDNS in
   * <code>us-east-1</code>, specify <code>ec2.internal</code>. If you're using
   * AmazonProvidedDNS in any other Region, specify
   * <code>region.compute.internal</code>. Otherwise, specify a custom domain name.
   * This value is used to complete unqualified DNS hostnames.</p> <p>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 option set is associated with
   * a VPC that has instances running operating systems that treat the value as a
   * single domain, specify only one domain name.</p> </li> <li> <p>
   * <code>domain-name-servers</code> - The IP addresses of up to four DNS servers,
   * or AmazonProvidedDNS. To specify multiple domain name servers in a single
   * parameter, separate the IP addresses using commas. To have your instances
   * receive custom DNS hostnames as specified in <code>domain-name</code>, you must
   * specify a custom DNS server.</p> </li> <li> <p> <code>ntp-servers</code> - The
   * IP addresses of up to eight Network Time Protocol (NTP) servers (four IPv4
   * addresses and four IPv6 addresses).</p> </li> <li> <p>
   * <code>netbios-name-servers</code> - The IP addresses of up to four NetBIOS name
   * servers.</p> </li> <li> <p> <code>netbios-node-type</code> - The NetBIOS node
   * type (1, 2, 4, or 8). We recommend that you specify 2. Broadcast and multicast
   * are not supported. For more information about NetBIOS node types, see <a
   * href="https://www.ietf.org/rfc/rfc2132.txt">RFC 2132</a>.</p> </li> <li> <p>
   * <code>ipv6-address-preferred-lease-time</code> - A value (in seconds, minutes,
   * hours, or years) for how frequently a running instance with an IPv6 assigned to
   * it goes through DHCPv6 lease renewal. Acceptable values are between 140 and
   * 2147483647 seconds (approximately 68 years). If no value is entered, the default
   * lease time is 140 seconds. If you use long-term addressing for EC2 instances,
   * you can increase the lease time and avoid frequent lease renewal requests. Lease
   * renewal typically occurs when half of the lease time has elapsed.</p> </li>
   * </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDhcpOptions">AWS
   * API Reference</a></p>
   */
  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 <typename CreateDhcpOptionsRequestT = Model::CreateDhcpOptionsRequest>
  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 <typename CreateDhcpOptionsRequestT = Model::CreateDhcpOptionsRequest>
  void CreateDhcpOptionsAsync(const CreateDhcpOptionsRequestT& request, const CreateDhcpOptionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateDhcpOptions, request, handler, context);
  }

  /**
   * <p>[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.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateEgressOnlyInternetGateway">AWS
   * API Reference</a></p>
   */
  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 <typename CreateEgressOnlyInternetGatewayRequestT = Model::CreateEgressOnlyInternetGatewayRequest>
  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 <typename CreateEgressOnlyInternetGatewayRequestT = Model::CreateEgressOnlyInternetGatewayRequest>
  void CreateEgressOnlyInternetGatewayAsync(const CreateEgressOnlyInternetGatewayRequestT& request,
                                            const CreateEgressOnlyInternetGatewayResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateEgressOnlyInternetGateway, request, handler, context);
  }

  /**
   * <p>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.</p> <p>A single EC2 Fleet can include multiple
   * launch specifications that vary by instance type, AMI, Availability Zone, or
   * subnet.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html">EC2
   * Fleet</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFleet">AWS API
   * Reference</a></p>
   */
  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 <typename CreateFleetRequestT = Model::CreateFleetRequest>
  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 <typename CreateFleetRequestT = Model::CreateFleetRequest>
  void CreateFleetAsync(const CreateFleetRequestT& request, const CreateFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateFleet, request, handler, context);
  }

  /**
   * <p>Creates one or more flow logs to capture information about IP traffic for a
   * specific network interface, subnet, or VPC. </p> <p>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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/flow-log-records.html">Flow
   * log records</a> in the <i>Amazon VPC User Guide</i>.</p> <p>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.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html">VPC Flow
   * Logs</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFlowLogs">AWS
   * API Reference</a></p>
   */
  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 <typename CreateFlowLogsRequestT = Model::CreateFlowLogsRequest>
  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 <typename CreateFlowLogsRequestT = Model::CreateFlowLogsRequest>
  void CreateFlowLogsAsync(const CreateFlowLogsRequestT& request, const CreateFlowLogsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateFlowLogs, request, handler, context);
  }

  /**
   * <p>Creates an Amazon FPGA Image (AFI) from the specified design checkpoint
   * (DCP).</p> <p>The create operation is asynchronous. To verify that the AFI was
   * successfully created and is ready for use, check the output logs.</p> <p>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 <a href="https://github.com/aws/aws-fpga/">Amazon Web
   * Services FPGA Hardware Development Kit</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFpgaImage">AWS
   * API Reference</a></p>
   */
  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 <typename CreateFpgaImageRequestT = Model::CreateFpgaImageRequest>
  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 <typename CreateFpgaImageRequestT = Model::CreateFpgaImageRequest>
  void CreateFpgaImageAsync(const CreateFpgaImageRequestT& request, const CreateFpgaImageResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateFpgaImage, request, handler, context);
  }

  /**
   * <p>Creates an Amazon EBS-backed AMI from an Amazon EBS-backed instance that is
   * either running or stopped.</p> <p>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.</p> <p>The location of the source instance determines
   * where you can create the snapshots of the AMI:</p> <ul> <li> <p>If the source
   * instance is in a Region, you must create the snapshots in the same Region as the
   * instance.</p> </li> <li> <p>If the source instance is in a Local Zone, you can
   * create the snapshots in the same Local Zone or in its parent Region.</p> </li>
   * </ul> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html">Create
   * an Amazon EBS-backed AMI</a> in the <i>Amazon Elastic Compute Cloud User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateImage">AWS API
   * Reference</a></p>
   */
  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 <typename CreateImageRequestT = Model::CreateImageRequest>
  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 <typename CreateImageRequestT = Model::CreateImageRequest>
  void CreateImageAsync(const CreateImageRequestT& request, const CreateImageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateImage, request, handler, context);
  }

  /**
   * <p>Creates a report that shows how your image is used across other Amazon Web
   * Services accounts. The report provides visibility into which accounts are using
   * the specified image, and how many resources (EC2 instances or launch templates)
   * are referencing it.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/your-ec2-ami-usage.html">View
   * your AMI usage</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateImageUsageReport">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateImageUsageReportOutcome CreateImageUsageReport(const Model::CreateImageUsageReportRequest& request) const;

  /**
   * A Callable wrapper for CreateImageUsageReport that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateImageUsageReportRequestT = Model::CreateImageUsageReportRequest>
  Model::CreateImageUsageReportOutcomeCallable CreateImageUsageReportCallable(const CreateImageUsageReportRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateImageUsageReport, request);
  }

  /**
   * An Async wrapper for CreateImageUsageReport that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename CreateImageUsageReportRequestT = Model::CreateImageUsageReportRequest>
  void CreateImageUsageReportAsync(const CreateImageUsageReportRequestT& request,
                                   const CreateImageUsageReportResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateImageUsageReport, request, handler, context);
  }

  /**
   * <p>Creates an EC2 Instance Connect Endpoint.</p> <p>An EC2 Instance Connect
   * Endpoint allows you to connect to an instance, without requiring the instance to
   * have a public IPv4 or public IPv6 address. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Connect-using-EC2-Instance-Connect-Endpoint.html">Connect
   * to your instances using EC2 Instance Connect Endpoint</a> in the <i>Amazon EC2
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceConnectEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename CreateInstanceConnectEndpointRequestT = Model::CreateInstanceConnectEndpointRequest>
  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 <typename CreateInstanceConnectEndpointRequestT = Model::CreateInstanceConnectEndpointRequest>
  void CreateInstanceConnectEndpointAsync(const CreateInstanceConnectEndpointRequestT& request,
                                          const CreateInstanceConnectEndpointResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateInstanceConnectEndpoint, request, handler, context);
  }

  /**
   * <p>Creates an event window in which scheduled events for the associated Amazon
   * EC2 instances can run.</p> <p>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.</p> <p>You can create up to 200 event windows per Amazon Web
   * Services Region.</p> <p>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 <a>AssociateInstanceEventWindow</a> API.</p>  <p>Event
   * windows are applicable only for scheduled events that stop, reboot, or terminate
   * instances.</p> <p>Event windows are <i>not</i> applicable for:</p> <ul> <li>
   * <p>Expedited scheduled events and network maintenance events. </p> </li> <li>
   * <p>Unscheduled maintenance such as AutoRecovery and unplanned reboots.</p> </li>
   * </ul>  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
   * event windows for scheduled events</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceEventWindow">AWS
   * API Reference</a></p>
   */
  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 <typename CreateInstanceEventWindowRequestT = Model::CreateInstanceEventWindowRequest>
  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 <typename CreateInstanceEventWindowRequestT = Model::CreateInstanceEventWindowRequest>
  void CreateInstanceEventWindowAsync(const CreateInstanceEventWindowResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const CreateInstanceEventWindowRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateInstanceEventWindow, request, handler, context);
  }

  /**
   * <p>Exports a running or stopped instance to an Amazon S3 bucket.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport.html">Exporting
   * an instance as a VM Using VM Import/Export</a> in the <i>VM Import/Export User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceExportTask">AWS
   * API Reference</a></p>
   */
  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 <typename CreateInstanceExportTaskRequestT = Model::CreateInstanceExportTaskRequest>
  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 <typename CreateInstanceExportTaskRequestT = Model::CreateInstanceExportTaskRequest>
  void CreateInstanceExportTaskAsync(const CreateInstanceExportTaskRequestT& request,
                                     const CreateInstanceExportTaskResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateInstanceExportTask, request, handler, context);
  }

  /**
   * <p>Creates an internet gateway for use with a VPC. After creating the internet
   * gateway, you attach it to a VPC using <a>AttachInternetGateway</a>.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html">Internet
   * gateways</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInternetGateway">AWS
   * API Reference</a></p>
   */
  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 <typename CreateInternetGatewayRequestT = Model::CreateInternetGatewayRequest>
  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 <typename CreateInternetGatewayRequestT = Model::CreateInternetGatewayRequest>
  void CreateInternetGatewayAsync(const CreateInternetGatewayResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const CreateInternetGatewayRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateInternetGateway, request, handler, context);
  }

  /**
   * <p> Creates an interruptible Capacity Reservation by specifying the number of
   * unused instances you want to allocate from your source reservation. This helps
   * you make unused capacity available for other workloads within your account while
   * maintaining control to reclaim it. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInterruptibleCapacityReservationAllocation">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateInterruptibleCapacityReservationAllocationOutcome CreateInterruptibleCapacityReservationAllocation(
      const Model::CreateInterruptibleCapacityReservationAllocationRequest& request) const;

  /**
   * A Callable wrapper for CreateInterruptibleCapacityReservationAllocation that returns a future to the operation so that it can be
   * executed in parallel to other requests.
   */
  template <
      typename CreateInterruptibleCapacityReservationAllocationRequestT = Model::CreateInterruptibleCapacityReservationAllocationRequest>
  Model::CreateInterruptibleCapacityReservationAllocationOutcomeCallable CreateInterruptibleCapacityReservationAllocationCallable(
      const CreateInterruptibleCapacityReservationAllocationRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateInterruptibleCapacityReservationAllocation, request);
  }

  /**
   * An Async wrapper for CreateInterruptibleCapacityReservationAllocation that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  template <
      typename CreateInterruptibleCapacityReservationAllocationRequestT = Model::CreateInterruptibleCapacityReservationAllocationRequest>
  void CreateInterruptibleCapacityReservationAllocationAsync(
      const CreateInterruptibleCapacityReservationAllocationRequestT& request,
      const CreateInterruptibleCapacityReservationAllocationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateInterruptibleCapacityReservationAllocation, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/create-ipam.html">Create an
   * IPAM</a> in the <i>Amazon VPC IPAM User Guide</i>. </p><p><h3>See Also:</h3>
   * <a href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpam">AWS
   * API Reference</a></p>
   */
  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 <typename CreateIpamRequestT = Model::CreateIpamRequest>
  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 <typename CreateIpamRequestT = Model::CreateIpamRequest>
  void CreateIpamAsync(const CreateIpamResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const CreateIpamRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateIpam, request, handler, context);
  }

  /**
   * <p>Create a verification token.</p> <p>A verification token is an Amazon Web
   * Services-generated random value that you can use to prove ownership of an
   * external resource. For example, you can use a verification token to validate
   * that you control a public IP address range when you bring an IP address range to
   * Amazon Web Services (BYOIP). </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamExternalResourceVerificationToken">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateIpamExternalResourceVerificationTokenOutcome CreateIpamExternalResourceVerificationToken(
      const Model::CreateIpamExternalResourceVerificationTokenRequest& request) const;

  /**
   * A Callable wrapper for CreateIpamExternalResourceVerificationToken that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename CreateIpamExternalResourceVerificationTokenRequestT = Model::CreateIpamExternalResourceVerificationTokenRequest>
  Model::CreateIpamExternalResourceVerificationTokenOutcomeCallable CreateIpamExternalResourceVerificationTokenCallable(
      const CreateIpamExternalResourceVerificationTokenRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamExternalResourceVerificationToken, request);
  }

  /**
   * An Async wrapper for CreateIpamExternalResourceVerificationToken that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename CreateIpamExternalResourceVerificationTokenRequestT = Model::CreateIpamExternalResourceVerificationTokenRequest>
  void CreateIpamExternalResourceVerificationTokenAsync(
      const CreateIpamExternalResourceVerificationTokenRequestT& request,
      const CreateIpamExternalResourceVerificationTokenResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateIpamExternalResourceVerificationToken, request, handler, context);
  }

  /**
   * <p>Creates an IPAM policy.</p> <p>An IPAM policy is a set of rules that define
   * how public IPv4 addresses from IPAM pools are allocated to Amazon Web Services
   * resources. Each rule maps an Amazon Web Services service to IPAM pools that the
   * service will use to get IP addresses. A single policy can have multiple rules
   * and be applied to multiple Amazon Web Services Regions. If the IPAM pool run out
   * of addresses then the services fallback to Amazon-provided IP addresses. A
   * policy can be applied to an individual Amazon Web Services account or an entity
   * within Amazon Web Services Organizations.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/define-public-ipv4-allocation-strategy-with-ipam-policies.html">Define
   * public IPv4 allocation strategy with IPAM policies</a> in the <i>Amazon VPC IPAM
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateIpamPolicyOutcome CreateIpamPolicy(const Model::CreateIpamPolicyRequest& request) const;

  /**
   * A Callable wrapper for CreateIpamPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateIpamPolicyRequestT = Model::CreateIpamPolicyRequest>
  Model::CreateIpamPolicyOutcomeCallable CreateIpamPolicyCallable(const CreateIpamPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamPolicy, request);
  }

  /**
   * An Async wrapper for CreateIpamPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename CreateIpamPolicyRequestT = Model::CreateIpamPolicyRequest>
  void CreateIpamPolicyAsync(const CreateIpamPolicyRequestT& request, const CreateIpamPolicyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateIpamPolicy, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/create-top-ipam.html">Create a
   * top-level pool</a> in the <i>Amazon VPC IPAM User Guide</i>. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamPool">AWS
   * API Reference</a></p>
   */
  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 <typename CreateIpamPoolRequestT = Model::CreateIpamPoolRequest>
  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 <typename CreateIpamPoolRequestT = Model::CreateIpamPoolRequest>
  void CreateIpamPoolAsync(const CreateIpamPoolRequestT& request, const CreateIpamPoolResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateIpamPool, request, handler, context);
  }

  /**
   * <p>Creates an IPAM prefix list resolver.</p> <p>An IPAM prefix list resolver is
   * a component that manages the synchronization between IPAM's CIDR selection rules
   * and customer-managed prefix lists. It automates connectivity configurations by
   * selecting CIDRs from IPAM's database based on your business logic and
   * synchronizing them with prefix lists used in resources such as VPC route tables
   * and security groups.</p> <p>For more information about IPAM prefix list
   * resolver, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/automate-prefix-list-updates.html">Automate
   * prefix list updates with IPAM</a> in the <i>Amazon VPC IPAM User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamPrefixListResolver">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateIpamPrefixListResolverOutcome CreateIpamPrefixListResolver(
      const Model::CreateIpamPrefixListResolverRequest& request) const;

  /**
   * A Callable wrapper for CreateIpamPrefixListResolver that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreateIpamPrefixListResolverRequestT = Model::CreateIpamPrefixListResolverRequest>
  Model::CreateIpamPrefixListResolverOutcomeCallable CreateIpamPrefixListResolverCallable(
      const CreateIpamPrefixListResolverRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamPrefixListResolver, request);
  }

  /**
   * An Async wrapper for CreateIpamPrefixListResolver that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename CreateIpamPrefixListResolverRequestT = Model::CreateIpamPrefixListResolverRequest>
  void CreateIpamPrefixListResolverAsync(const CreateIpamPrefixListResolverRequestT& request,
                                         const CreateIpamPrefixListResolverResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateIpamPrefixListResolver, request, handler, context);
  }

  /**
   * <p>Creates an IPAM prefix list resolver target.</p> <p>An IPAM prefix list
   * resolver target is an association between a specific customer-managed prefix
   * list and an IPAM prefix list resolver. The target enables the resolver to
   * synchronize CIDRs selected by its rules into the specified prefix list, which
   * can then be referenced in Amazon Web Services resources.</p> <p>For more
   * information about IPAM prefix list resolver, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/automate-prefix-list-updates.html">Automate
   * prefix list updates with IPAM</a> in the <i>Amazon VPC IPAM User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamPrefixListResolverTarget">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateIpamPrefixListResolverTargetOutcome CreateIpamPrefixListResolverTarget(
      const Model::CreateIpamPrefixListResolverTargetRequest& request) const;

  /**
   * A Callable wrapper for CreateIpamPrefixListResolverTarget that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename CreateIpamPrefixListResolverTargetRequestT = Model::CreateIpamPrefixListResolverTargetRequest>
  Model::CreateIpamPrefixListResolverTargetOutcomeCallable CreateIpamPrefixListResolverTargetCallable(
      const CreateIpamPrefixListResolverTargetRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamPrefixListResolverTarget, request);
  }

  /**
   * An Async wrapper for CreateIpamPrefixListResolverTarget that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename CreateIpamPrefixListResolverTargetRequestT = Model::CreateIpamPrefixListResolverTargetRequest>
  void CreateIpamPrefixListResolverTargetAsync(const CreateIpamPrefixListResolverTargetRequestT& request,
                                               const CreateIpamPrefixListResolverTargetResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateIpamPrefixListResolverTarget, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamResourceDiscovery">AWS
   * API Reference</a></p>
   */
  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 <typename CreateIpamResourceDiscoveryRequestT = Model::CreateIpamResourceDiscoveryRequest>
  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 <typename CreateIpamResourceDiscoveryRequestT = Model::CreateIpamResourceDiscoveryRequest>
  void CreateIpamResourceDiscoveryAsync(const CreateIpamResourceDiscoveryResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const CreateIpamResourceDiscoveryRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateIpamResourceDiscovery, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/add-scope-ipam.html">Add a
   * scope</a> in the <i>Amazon VPC IPAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamScope">AWS
   * API Reference</a></p>
   */
  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 <typename CreateIpamScopeRequestT = Model::CreateIpamScopeRequest>
  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 <typename CreateIpamScopeRequestT = Model::CreateIpamScopeRequest>
  void CreateIpamScopeAsync(const CreateIpamScopeRequestT& request, const CreateIpamScopeResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateIpamScope, request, handler, context);
  }

  /**
   * <p>Creates an ED25519 or 2048-bit RSA key pair with the specified name and in
   * the specified 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.</p> <p>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
   * <a>ImportKeyPair</a>.</p> <p>You can have up to 5,000 key pairs per Amazon Web
   * Services Region.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Amazon
   * EC2 key pairs</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateKeyPair">AWS
   * API Reference</a></p>
   */
  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 <typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
  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 <typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
  void CreateKeyPairAsync(const CreateKeyPairRequestT& request, const CreateKeyPairResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateKeyPair, request, handler, context);
  }

  /**
   * <p>Creates a launch template.</p> <p>A launch template contains the parameters
   * to launch an instance. When you launch an instance using <a>RunInstances</a>,
   * you can specify a launch template instead of providing the launch parameters in
   * the request. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">Store
   * instance launch parameters in Amazon EC2 launch templates</a> in the <i>Amazon
   * EC2 User Guide</i>.</p> <p>To clone an existing launch template as the basis for
   * a new launch template, use the Amazon EC2 console. The API, SDKs, and CLI do not
   * support cloning a template. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#create-launch-template-from-existing-launch-template">Create
   * a launch template from an existing launch template</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLaunchTemplate">AWS
   * API Reference</a></p>
   */
  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 <typename CreateLaunchTemplateRequestT = Model::CreateLaunchTemplateRequest>
  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 <typename CreateLaunchTemplateRequestT = Model::CreateLaunchTemplateRequest>
  void CreateLaunchTemplateAsync(const CreateLaunchTemplateRequestT& request, const CreateLaunchTemplateResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateLaunchTemplate, request, handler, context);
  }

  /**
   * <p>Creates a new version of a launch template. You must specify an existing
   * launch template, either by name or ID. You can determine whether the new version
   * inherits parameters from a source version, and add or overwrite parameters as
   * needed.</p> <p>Launch template versions are numbered in the order in which they
   * are created. You can't specify, change, or replace the numbering of launch
   * template versions.</p> <p>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 the changes that you require.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-launch-template-versions.html">Modify
   * a launch template (manage launch template versions)</a> in the <i>Amazon EC2
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLaunchTemplateVersion">AWS
   * API Reference</a></p>
   */
  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 <typename CreateLaunchTemplateVersionRequestT = Model::CreateLaunchTemplateVersionRequest>
  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 <typename CreateLaunchTemplateVersionRequestT = Model::CreateLaunchTemplateVersionRequest>
  void CreateLaunchTemplateVersionAsync(const CreateLaunchTemplateVersionRequestT& request,
                                        const CreateLaunchTemplateVersionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateLaunchTemplateVersion, request, handler, context);
  }

  /**
   * <p>Creates a static route for the specified local gateway route table. You must
   * specify one of the following targets: </p> <ul> <li> <p>
   * <code>LocalGatewayVirtualInterfaceGroupId</code> </p> </li> <li> <p>
   * <code>NetworkInterfaceId</code> </p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRoute">AWS
   * API Reference</a></p>
   */
  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 <typename CreateLocalGatewayRouteRequestT = Model::CreateLocalGatewayRouteRequest>
  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 <typename CreateLocalGatewayRouteRequestT = Model::CreateLocalGatewayRouteRequest>
  void CreateLocalGatewayRouteAsync(const CreateLocalGatewayRouteRequestT& request,
                                    const CreateLocalGatewayRouteResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateLocalGatewayRoute, request, handler, context);
  }

  /**
   * <p> Creates a local gateway route table. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename CreateLocalGatewayRouteTableRequestT = Model::CreateLocalGatewayRouteTableRequest>
  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 <typename CreateLocalGatewayRouteTableRequestT = Model::CreateLocalGatewayRouteTableRequest>
  void CreateLocalGatewayRouteTableAsync(const CreateLocalGatewayRouteTableRequestT& request,
                                         const CreateLocalGatewayRouteTableResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateLocalGatewayRouteTable, request, handler, context);
  }

  /**
   * <p> Creates a local gateway route table virtual interface group association.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation">AWS
   * API Reference</a></p>
   */
  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 <typename CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT =
                Model::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest>
  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 <typename CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT =
                Model::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest>
  void CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationAsync(
      const CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT& request,
      const CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation, request, handler, context);
  }

  /**
   * <p>Associates the specified VPC with the specified local gateway route
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTableVpcAssociation">AWS
   * API Reference</a></p>
   */
  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 <typename CreateLocalGatewayRouteTableVpcAssociationRequestT = Model::CreateLocalGatewayRouteTableVpcAssociationRequest>
  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 <typename CreateLocalGatewayRouteTableVpcAssociationRequestT = Model::CreateLocalGatewayRouteTableVpcAssociationRequest>
  void CreateLocalGatewayRouteTableVpcAssociationAsync(
      const CreateLocalGatewayRouteTableVpcAssociationRequestT& request,
      const CreateLocalGatewayRouteTableVpcAssociationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateLocalGatewayRouteTableVpcAssociation, request, handler, context);
  }

  /**
   * <p>Create a virtual interface for a local gateway. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateLocalGatewayVirtualInterfaceOutcome CreateLocalGatewayVirtualInterface(
      const Model::CreateLocalGatewayVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for CreateLocalGatewayVirtualInterface that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename CreateLocalGatewayVirtualInterfaceRequestT = Model::CreateLocalGatewayVirtualInterfaceRequest>
  Model::CreateLocalGatewayVirtualInterfaceOutcomeCallable CreateLocalGatewayVirtualInterfaceCallable(
      const CreateLocalGatewayVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLocalGatewayVirtualInterface, request);
  }

  /**
   * An Async wrapper for CreateLocalGatewayVirtualInterface that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename CreateLocalGatewayVirtualInterfaceRequestT = Model::CreateLocalGatewayVirtualInterfaceRequest>
  void CreateLocalGatewayVirtualInterfaceAsync(const CreateLocalGatewayVirtualInterfaceRequestT& request,
                                               const CreateLocalGatewayVirtualInterfaceResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateLocalGatewayVirtualInterface, request, handler, context);
  }

  /**
   * <p>Create a local gateway virtual interface group.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayVirtualInterfaceGroup">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateLocalGatewayVirtualInterfaceGroupOutcome CreateLocalGatewayVirtualInterfaceGroup(
      const Model::CreateLocalGatewayVirtualInterfaceGroupRequest& request) const;

  /**
   * A Callable wrapper for CreateLocalGatewayVirtualInterfaceGroup that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename CreateLocalGatewayVirtualInterfaceGroupRequestT = Model::CreateLocalGatewayVirtualInterfaceGroupRequest>
  Model::CreateLocalGatewayVirtualInterfaceGroupOutcomeCallable CreateLocalGatewayVirtualInterfaceGroupCallable(
      const CreateLocalGatewayVirtualInterfaceGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLocalGatewayVirtualInterfaceGroup, request);
  }

  /**
   * An Async wrapper for CreateLocalGatewayVirtualInterfaceGroup that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename CreateLocalGatewayVirtualInterfaceGroupRequestT = Model::CreateLocalGatewayVirtualInterfaceGroupRequest>
  void CreateLocalGatewayVirtualInterfaceGroupAsync(const CreateLocalGatewayVirtualInterfaceGroupRequestT& request,
                                                    const CreateLocalGatewayVirtualInterfaceGroupResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateLocalGatewayVirtualInterfaceGroup, request, handler, context);
  }

  /**
   * <p>Creates a System Integrity Protection (SIP) modification task to configure
   * the SIP settings for an x86 Mac instance or Apple silicon Mac instance. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/mac-sip-settings.html#mac-sip-configure">
   * Configure SIP for Amazon EC2 instances</a> in the <i>Amazon EC2 User
   * Guide</i>.</p> <p>When you configure the SIP settings for your instance, you can
   * either enable or disable all SIP settings, or you can specify a custom SIP
   * configuration that selectively enables or disables specific SIP settings.</p>
   *  <p>If you implement a custom configuration, <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/mac-sip-settings.html#mac-sip-check-settings">
   * connect to the instance and verify the settings</a> to ensure that your
   * requirements are properly implemented and functioning as intended.</p> <p>SIP
   * configurations might change with macOS updates. We recommend that you review
   * custom SIP settings after any macOS version upgrade to ensure continued
   * compatibility and proper functionality of your security configurations.</p>
   *  <p>To enable or disable all SIP settings, use the
   * <b>MacSystemIntegrityProtectionStatus</b> parameter only. For example, to enable
   * all SIP settings, specify the following:</p> <ul> <li> <p>
   * <code>MacSystemIntegrityProtectionStatus=enabled</code> </p> </li> </ul> <p>To
   * specify a custom configuration that selectively enables or disables specific SIP
   * settings, use the <b>MacSystemIntegrityProtectionStatus</b> parameter to enable
   * or disable all SIP settings, and then use the
   * <b>MacSystemIntegrityProtectionConfiguration</b> parameter to specify
   * exceptions. In this case, the exceptions you specify for
   * <b>MacSystemIntegrityProtectionConfiguration</b> override the value you specify
   * for <b>MacSystemIntegrityProtectionStatus</b>. For example, to enable all SIP
   * settings, except <code>NvramProtections</code>, specify the following:</p> <ul>
   * <li> <p> <code>MacSystemIntegrityProtectionStatus=enabled</code> </p> </li> <li>
   * <p> <code>MacSystemIntegrityProtectionConfigurationRequest
   * "NvramProtections=disabled"</code> </p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateMacSystemIntegrityProtectionModificationTask">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateMacSystemIntegrityProtectionModificationTaskOutcome CreateMacSystemIntegrityProtectionModificationTask(
      const Model::CreateMacSystemIntegrityProtectionModificationTaskRequest& request) const;

  /**
   * A Callable wrapper for CreateMacSystemIntegrityProtectionModificationTask that returns a future to the operation so that it can be
   * executed in parallel to other requests.
   */
  template <typename CreateMacSystemIntegrityProtectionModificationTaskRequestT =
                Model::CreateMacSystemIntegrityProtectionModificationTaskRequest>
  Model::CreateMacSystemIntegrityProtectionModificationTaskOutcomeCallable CreateMacSystemIntegrityProtectionModificationTaskCallable(
      const CreateMacSystemIntegrityProtectionModificationTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateMacSystemIntegrityProtectionModificationTask, request);
  }

  /**
   * An Async wrapper for CreateMacSystemIntegrityProtectionModificationTask that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  template <typename CreateMacSystemIntegrityProtectionModificationTaskRequestT =
                Model::CreateMacSystemIntegrityProtectionModificationTaskRequest>
  void CreateMacSystemIntegrityProtectionModificationTaskAsync(
      const CreateMacSystemIntegrityProtectionModificationTaskRequestT& request,
      const CreateMacSystemIntegrityProtectionModificationTaskResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateMacSystemIntegrityProtectionModificationTask, request, handler, context);
  }

  /**
   * <p>Creates a managed prefix list. You can specify entries for the prefix list.
   * Each entry consists of a CIDR block and an optional description.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateManagedPrefixList">AWS
   * API Reference</a></p>
   */
  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 <typename CreateManagedPrefixListRequestT = Model::CreateManagedPrefixListRequest>
  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 <typename CreateManagedPrefixListRequestT = Model::CreateManagedPrefixListRequest>
  void CreateManagedPrefixListAsync(const CreateManagedPrefixListRequestT& request,
                                    const CreateManagedPrefixListResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateManagedPrefixList, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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.</p> <p>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.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html">NAT
   * gateways</a> in the <i>Amazon VPC User Guide</i>.</p>  <p>When you
   * create a public NAT gateway and assign it an EIP or secondary EIPs, the network
   * border group of the EIPs must match the network border group of the Availability
   * Zone (AZ) that the public NAT gateway is in. If it's not the same, the NAT
   * gateway will fail to launch. You can see the network border group for the
   * subnet's AZ by viewing the details of the subnet. Similarly, you can view the
   * network border group of an EIP by viewing the details of the EIP address. For
   * more information about network border groups and EIPs, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/WorkWithEIPs.html">Allocate
   * an Elastic IP address</a> in the <i>Amazon VPC User Guide</i>. </p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNatGateway">AWS
   * API Reference</a></p>
   */
  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 <typename CreateNatGatewayRequestT = Model::CreateNatGatewayRequest>
  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 <typename CreateNatGatewayRequestT = Model::CreateNatGatewayRequest>
  void CreateNatGatewayAsync(const CreateNatGatewayResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const CreateNatGatewayRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateNatGateway, request, handler, context);
  }

  /**
   * <p>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.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
   * ACLs</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAcl">AWS
   * API Reference</a></p>
   */
  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 <typename CreateNetworkAclRequestT = Model::CreateNetworkAclRequest>
  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 <typename CreateNetworkAclRequestT = Model::CreateNetworkAclRequest>
  void CreateNetworkAclAsync(const CreateNetworkAclRequestT& request, const CreateNetworkAclResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateNetworkAcl, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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.</p> <p>After you add an entry, you can't modify it; you must either
   * replace it, or create an entry and delete the old one.</p> <p>For more
   * information about network ACLs, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
   * ACLs</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAclEntry">AWS
   * API Reference</a></p>
   */
  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 <typename CreateNetworkAclEntryRequestT = Model::CreateNetworkAclEntryRequest>
  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 <typename CreateNetworkAclEntryRequestT = Model::CreateNetworkAclEntryRequest>
  void CreateNetworkAclEntryAsync(const CreateNetworkAclEntryRequestT& request, const CreateNetworkAclEntryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateNetworkAclEntry, request, handler, context);
  }

  /**
   * <p>Creates a Network Access Scope.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/">Amazon
   * Web Services Network Access Analyzer Guide</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInsightsAccessScope">AWS
   * API Reference</a></p>
   */
  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 <typename CreateNetworkInsightsAccessScopeRequestT = Model::CreateNetworkInsightsAccessScopeRequest>
  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 <typename CreateNetworkInsightsAccessScopeRequestT = Model::CreateNetworkInsightsAccessScopeRequest>
  void CreateNetworkInsightsAccessScopeAsync(const CreateNetworkInsightsAccessScopeRequestT& request,
                                             const CreateNetworkInsightsAccessScopeResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateNetworkInsightsAccessScope, request, handler, context);
  }

  /**
   * <p>Creates a path to analyze for reachability.</p> <p>Reachability Analyzer
   * enables you to analyze and debug network reachability between two resources in
   * your virtual private cloud (VPC). For more information, see the <a
   * href="https://docs.aws.amazon.com/vpc/latest/reachability/">Reachability
   * Analyzer Guide</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInsightsPath">AWS
   * API Reference</a></p>
   */
  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 <typename CreateNetworkInsightsPathRequestT = Model::CreateNetworkInsightsPathRequest>
  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 <typename CreateNetworkInsightsPathRequestT = Model::CreateNetworkInsightsPathRequest>
  void CreateNetworkInsightsPathAsync(const CreateNetworkInsightsPathRequestT& request,
                                      const CreateNetworkInsightsPathResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateNetworkInsightsPath, request, handler, context);
  }

  /**
   * <p>Creates a network interface in the specified subnet.</p> <p>The number of IP
   * addresses you can assign to a network interface varies by instance type.</p>
   * <p>For more information about network interfaces, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html">Elastic
   * network interfaces</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterface">AWS
   * API Reference</a></p>
   */
  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 <typename CreateNetworkInterfaceRequestT = Model::CreateNetworkInterfaceRequest>
  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 <typename CreateNetworkInterfaceRequestT = Model::CreateNetworkInterfaceRequest>
  void CreateNetworkInterfaceAsync(const CreateNetworkInterfaceRequestT& request,
                                   const CreateNetworkInterfaceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateNetworkInterface, request, handler, context);
  }

  /**
   * <p>Grants an Amazon Web Services-authorized account permission to attach the
   * specified network interface to an instance in their account.</p> <p>You can
   * grant permission to a single Amazon Web Services account only, and only one
   * account at a time.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterfacePermission">AWS
   * API Reference</a></p>
   */
  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 <typename CreateNetworkInterfacePermissionRequestT = Model::CreateNetworkInterfacePermissionRequest>
  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 <typename CreateNetworkInterfacePermissionRequestT = Model::CreateNetworkInterfacePermissionRequest>
  void CreateNetworkInterfacePermissionAsync(const CreateNetworkInterfacePermissionRequestT& request,
                                             const CreateNetworkInterfacePermissionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateNetworkInterfacePermission, request, handler, context);
  }

  /**
   * <p>Creates a placement group in which to launch instances. The strategy of the
   * placement group determines how the instances are organized within the group.
   * </p> <p>A <code>cluster</code> placement group is a logical grouping of
   * instances within a single Availability Zone that benefit from low network
   * latency, high network throughput. A <code>spread</code> placement group places
   * instances on distinct hardware. A <code>partition</code> 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.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">Placement
   * groups</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePlacementGroup">AWS
   * API Reference</a></p>
   */
  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 <typename CreatePlacementGroupRequestT = Model::CreatePlacementGroupRequest>
  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 <typename CreatePlacementGroupRequestT = Model::CreatePlacementGroupRequest>
  void CreatePlacementGroupAsync(const CreatePlacementGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const CreatePlacementGroupRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreatePlacementGroup, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribePublicIpv4Pools.html">DescribePublicIpv4Pools</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePublicIpv4Pool">AWS
   * API Reference</a></p>
   */
  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 <typename CreatePublicIpv4PoolRequestT = Model::CreatePublicIpv4PoolRequest>
  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 <typename CreatePublicIpv4PoolRequestT = Model::CreatePublicIpv4PoolRequest>
  void CreatePublicIpv4PoolAsync(const CreatePublicIpv4PoolResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const CreatePublicIpv4PoolRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreatePublicIpv4Pool, request, handler, context);
  }

  /**
   * <p>Replaces the EBS-backed root volume for a <code>running</code> 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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/replace-root.html">Replace
   * a root volume</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReplaceRootVolumeTask">AWS
   * API Reference</a></p>
   */
  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 <typename CreateReplaceRootVolumeTaskRequestT = Model::CreateReplaceRootVolumeTaskRequest>
  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 <typename CreateReplaceRootVolumeTaskRequestT = Model::CreateReplaceRootVolumeTaskRequest>
  void CreateReplaceRootVolumeTaskAsync(const CreateReplaceRootVolumeTaskRequestT& request,
                                        const CreateReplaceRootVolumeTaskResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateReplaceRootVolumeTask, request, handler, context);
  }

  /**
   * <p>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 <a>DescribeReservedInstances</a> operation.</p>  <p>Only Standard
   * Reserved Instances can be sold in the Reserved Instance Marketplace. Convertible
   * Reserved Instances cannot be sold.</p>  <p>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.</p> <p>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
   * <a>DescribeReservedInstancesListings</a> operation.</p> <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Sell
   * in the Reserved Instance Marketplace</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReservedInstancesListing">AWS
   * API Reference</a></p>
   */
  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 <typename CreateReservedInstancesListingRequestT = Model::CreateReservedInstancesListingRequest>
  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 <typename CreateReservedInstancesListingRequestT = Model::CreateReservedInstancesListingRequest>
  void CreateReservedInstancesListingAsync(const CreateReservedInstancesListingRequestT& request,
                                           const CreateReservedInstancesListingResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateReservedInstancesListing, request, handler, context);
  }

  /**
   * <p>Starts a task that restores an AMI from an Amazon S3 object that was
   * previously created by using <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateStoreImageTask.html">CreateStoreImageTask</a>.</p>
   * <p>To use this API, you must have the required permissions. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-ami-store-restore.html#ami-s3-permissions">Permissions
   * for storing and restoring AMIs using S3</a> in the <i>Amazon EC2 User
   * Guide</i>.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html">Store
   * and restore an AMI using S3</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRestoreImageTask">AWS
   * API Reference</a></p>
   */
  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 <typename CreateRestoreImageTaskRequestT = Model::CreateRestoreImageTaskRequest>
  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 <typename CreateRestoreImageTaskRequestT = Model::CreateRestoreImageTaskRequest>
  void CreateRestoreImageTaskAsync(const CreateRestoreImageTaskRequestT& request,
                                   const CreateRestoreImageTaskResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateRestoreImageTask, request, handler, context);
  }

  /**
   * <p>Creates a route in a route table within a VPC.</p> <p>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.</p> <p>When determining how to route
   * traffic, we use the route with the most specific match. For example, traffic is
   * destined for the IPv4 address <code>192.0.2.3</code>, and the route table
   * includes the following two IPv4 routes:</p> <ul> <li> <p>
   * <code>192.0.2.0/24</code> (goes to some target A)</p> </li> <li> <p>
   * <code>192.0.2.0/28</code> (goes to some target B)</p> </li> </ul> <p>Both routes
   * apply to the traffic destined for <code>192.0.2.3</code>. 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.</p>
   * <p>For more information about route tables, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
   * tables</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRoute">AWS API
   * Reference</a></p>
   */
  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 <typename CreateRouteRequestT = Model::CreateRouteRequest>
  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 <typename CreateRouteRequestT = Model::CreateRouteRequest>
  void CreateRouteAsync(const CreateRouteRequestT& request, const CreateRouteResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateRoute, request, handler, context);
  }

  /**
   * <p>Creates a new route server to manage dynamic routing in a VPC.</p> <p>Amazon
   * VPC Route Server simplifies routing for traffic between workloads that are
   * deployed within a VPC and its internet gateways. With this feature, VPC Route
   * Server dynamically updates VPC and internet gateway route tables with your
   * preferred IPv4 or IPv6 routes to achieve routing fault tolerance for those
   * workloads. This enables you to automatically reroute traffic within a VPC, which
   * increases the manageability of VPC routing and interoperability with third-party
   * workloads.</p> <p>Route server supports the follow route table types:</p> <ul>
   * <li> <p>VPC route tables not associated with subnets</p> </li> <li> <p>Subnet
   * route tables</p> </li> <li> <p>Internet gateway route tables</p> </li> </ul>
   * <p>Route server does not support route tables associated with virtual private
   * gateways. To propagate routes into a transit gateway route table, use <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html">Transit
   * Gateway Connect</a>.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRouteServer">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateRouteServerOutcome CreateRouteServer(const Model::CreateRouteServerRequest& request) const;

  /**
   * A Callable wrapper for CreateRouteServer that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateRouteServerRequestT = Model::CreateRouteServerRequest>
  Model::CreateRouteServerOutcomeCallable CreateRouteServerCallable(const CreateRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateRouteServer, request);
  }

  /**
   * An Async wrapper for CreateRouteServer that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename CreateRouteServerRequestT = Model::CreateRouteServerRequest>
  void CreateRouteServerAsync(const CreateRouteServerRequestT& request, const CreateRouteServerResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateRouteServer, request, handler, context);
  }

  /**
   * <p>Creates a new endpoint for a route server in a specified subnet.</p> <p>A
   * route server endpoint is an Amazon Web Services-managed component inside a
   * subnet that facilitates <a
   * href="https://en.wikipedia.org/wiki/Border_Gateway_Protocol">BGP (Border Gateway
   * Protocol)</a> connections between your route server and your BGP peers.</p>
   * <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRouteServerEndpoint">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateRouteServerEndpointOutcome CreateRouteServerEndpoint(const Model::CreateRouteServerEndpointRequest& request) const;

  /**
   * A Callable wrapper for CreateRouteServerEndpoint that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateRouteServerEndpointRequestT = Model::CreateRouteServerEndpointRequest>
  Model::CreateRouteServerEndpointOutcomeCallable CreateRouteServerEndpointCallable(
      const CreateRouteServerEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateRouteServerEndpoint, request);
  }

  /**
   * An Async wrapper for CreateRouteServerEndpoint that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename CreateRouteServerEndpointRequestT = Model::CreateRouteServerEndpointRequest>
  void CreateRouteServerEndpointAsync(const CreateRouteServerEndpointRequestT& request,
                                      const CreateRouteServerEndpointResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateRouteServerEndpoint, request, handler, context);
  }

  /**
   * <p>Creates a new BGP peer for a specified route server endpoint.</p> <p>A route
   * server peer is a session between a route server endpoint and the device deployed
   * in Amazon Web Services (such as a firewall appliance or other network security
   * function running on an EC2 instance). The device must meet these
   * requirements:</p> <ul> <li> <p>Have an elastic network interface in the VPC</p>
   * </li> <li> <p>Support BGP (Border Gateway Protocol)</p> </li> <li> <p>Can
   * initiate BGP sessions</p> </li> </ul> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRouteServerPeer">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateRouteServerPeerOutcome CreateRouteServerPeer(const Model::CreateRouteServerPeerRequest& request) const;

  /**
   * A Callable wrapper for CreateRouteServerPeer that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateRouteServerPeerRequestT = Model::CreateRouteServerPeerRequest>
  Model::CreateRouteServerPeerOutcomeCallable CreateRouteServerPeerCallable(const CreateRouteServerPeerRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateRouteServerPeer, request);
  }

  /**
   * An Async wrapper for CreateRouteServerPeer that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename CreateRouteServerPeerRequestT = Model::CreateRouteServerPeerRequest>
  void CreateRouteServerPeerAsync(const CreateRouteServerPeerRequestT& request, const CreateRouteServerPeerResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateRouteServerPeer, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
   * tables</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename CreateRouteTableRequestT = Model::CreateRouteTableRequest>
  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 <typename CreateRouteTableRequestT = Model::CreateRouteTableRequest>
  void CreateRouteTableAsync(const CreateRouteTableRequestT& request, const CreateRouteTableResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateRouteTable, request, handler, context);
  }

  /**
   * <p>Creates a secondary network.</p> <p>The allowed size for a secondary network
   * CIDR block is between /28 netmask (16 IP addresses) and /12 netmask (1,048,576
   * IP addresses).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSecondaryNetwork">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateSecondaryNetworkOutcome CreateSecondaryNetwork(const Model::CreateSecondaryNetworkRequest& request) const;

  /**
   * A Callable wrapper for CreateSecondaryNetwork that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateSecondaryNetworkRequestT = Model::CreateSecondaryNetworkRequest>
  Model::CreateSecondaryNetworkOutcomeCallable CreateSecondaryNetworkCallable(const CreateSecondaryNetworkRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSecondaryNetwork, request);
  }

  /**
   * An Async wrapper for CreateSecondaryNetwork that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename CreateSecondaryNetworkRequestT = Model::CreateSecondaryNetworkRequest>
  void CreateSecondaryNetworkAsync(const CreateSecondaryNetworkRequestT& request,
                                   const CreateSecondaryNetworkResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateSecondaryNetwork, request, handler, context);
  }

  /**
   * <p>Creates a secondary subnet in a secondary network.</p> <p>A secondary subnet
   * CIDR block must not overlap with the CIDR block of an existing secondary subnet
   * in the secondary network. After you create a secondary subnet, you can't change
   * its CIDR block.</p> <p>The allowed size for a secondary subnet CIDR block is
   * between /28 netmask (16 IP addresses) and /12 netmask (1,048,576 IP addresses).
   * Amazon reserves the first four IP addresses and the last IP address in each
   * secondary subnet for internal use.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSecondarySubnet">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateSecondarySubnetOutcome CreateSecondarySubnet(const Model::CreateSecondarySubnetRequest& request) const;

  /**
   * A Callable wrapper for CreateSecondarySubnet that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateSecondarySubnetRequestT = Model::CreateSecondarySubnetRequest>
  Model::CreateSecondarySubnetOutcomeCallable CreateSecondarySubnetCallable(const CreateSecondarySubnetRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSecondarySubnet, request);
  }

  /**
   * An Async wrapper for CreateSecondarySubnet that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename CreateSecondarySubnetRequestT = Model::CreateSecondarySubnetRequest>
  void CreateSecondarySubnetAsync(const CreateSecondarySubnetRequestT& request, const CreateSecondarySubnetResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateSecondarySubnet, request, handler, context);
  }

  /**
   * <p>Creates a security group.</p> <p>A security group acts as a virtual firewall
   * for your instance to control inbound and outbound traffic. For more information,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Amazon
   * EC2 security groups</a> in the <i>Amazon EC2 User Guide</i> and <a
   * href="https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html">Security
   * groups for your VPC</a> in the <i>Amazon VPC User Guide</i>.</p> <p>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.</p> <p>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.</p> <p>You can add
   * or remove rules from your security groups using
   * <a>AuthorizeSecurityGroupIngress</a>, <a>AuthorizeSecurityGroupEgress</a>,
   * <a>RevokeSecurityGroupIngress</a>, and <a>RevokeSecurityGroupEgress</a>.</p>
   * <p>For more information about VPC security group limits, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon
   * VPC Limits</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSecurityGroup">AWS
   * API Reference</a></p>
   */
  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 <typename CreateSecurityGroupRequestT = Model::CreateSecurityGroupRequest>
  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 <typename CreateSecurityGroupRequestT = Model::CreateSecurityGroupRequest>
  void CreateSecurityGroupAsync(const CreateSecurityGroupRequestT& request, const CreateSecurityGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateSecurityGroup, request, handler, context);
  }

  /**
   * <p>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.</p> <p>The location of the source EBS volume
   * determines where you can create the snapshot.</p> <ul> <li> <p>If the source
   * volume is in a Region, you must create the snapshot in the same Region as the
   * volume.</p> </li> <li> <p>If the source volume is in a Local Zone, you can
   * create the snapshot in the same Local Zone or in its parent Amazon Web Services
   * Region.</p> </li> <li> <p>If the source volume is on an Outpost, you can create
   * the snapshot on the same Outpost or in its parent Amazon Web Services
   * Region.</p> </li> </ul> <p>When a snapshot is created, any Amazon Web Services
   * Marketplace product codes that are associated with the source volume are
   * propagated to the snapshot.</p> <p>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 <code>pending</code>.</p> <p>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.</p> <p>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. For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html">Amazon
   * EBS encryption</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshot">AWS
   * API Reference</a></p>
   */
  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 <typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
  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 <typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
  void CreateSnapshotAsync(const CreateSnapshotRequestT& request, const CreateSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateSnapshot, request, handler, context);
  }

  /**
   * <p>Creates crash-consistent snapshots of multiple EBS volumes attached to an
   * Amazon EC2 instance. Volumes are chosen by specifying an instance. Each volume
   * attached to the specified instance will produce one snapshot 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.</p> <p>The
   * location of the source instance determines where you can create the
   * snapshots.</p> <ul> <li> <p>If the source instance is in a Region, you must
   * create the snapshots in the same Region as the instance.</p> </li> <li> <p>If
   * the source instance is in a Local Zone, you can create the snapshots in the same
   * Local Zone or in its parent Amazon Web Services Region.</p> </li> <li> <p>If the
   * source instance is on an Outpost, you can create the snapshots on the same
   * Outpost or in its parent Amazon Web Services Region.</p> </li> </ul><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshots">AWS
   * API Reference</a></p>
   */
  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 <typename CreateSnapshotsRequestT = Model::CreateSnapshotsRequest>
  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 <typename CreateSnapshotsRequestT = Model::CreateSnapshotsRequest>
  void CreateSnapshotsAsync(const CreateSnapshotsRequestT& request, const CreateSnapshotsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateSnapshots, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html">Spot
   * Instance data feed</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSpotDatafeedSubscription">AWS
   * API Reference</a></p>
   */
  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 <typename CreateSpotDatafeedSubscriptionRequestT = Model::CreateSpotDatafeedSubscriptionRequest>
  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 <typename CreateSpotDatafeedSubscriptionRequestT = Model::CreateSpotDatafeedSubscriptionRequest>
  void CreateSpotDatafeedSubscriptionAsync(const CreateSpotDatafeedSubscriptionRequestT& request,
                                           const CreateSpotDatafeedSubscriptionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateSpotDatafeedSubscription, request, handler, context);
  }

  /**
   * <p>Stores an AMI as a single object in an Amazon S3 bucket.</p> <p>To use this
   * API, you must have the required permissions. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-ami-store-restore.html#ami-s3-permissions">Permissions
   * for storing and restoring AMIs using S3</a> in the <i>Amazon EC2 User
   * Guide</i>.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html">Store
   * and restore an AMI using S3</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateStoreImageTask">AWS
   * API Reference</a></p>
   */
  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 <typename CreateStoreImageTaskRequestT = Model::CreateStoreImageTaskRequest>
  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 <typename CreateStoreImageTaskRequestT = Model::CreateStoreImageTaskRequest>
  void CreateStoreImageTaskAsync(const CreateStoreImageTaskRequestT& request, const CreateStoreImageTaskResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateStoreImageTask, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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.</p> <p>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.</p> <p>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. </p> <p>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.</p> <p>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.</p> <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/configure-subnets.html">Subnets</a>
   * in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnet">AWS
   * API Reference</a></p>
   */
  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 <typename CreateSubnetRequestT = Model::CreateSubnetRequest>
  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 <typename CreateSubnetRequestT = Model::CreateSubnetRequest>
  void CreateSubnetAsync(const CreateSubnetRequestT& request, const CreateSubnetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateSubnet, request, handler, context);
  }

  /**
   * <p>Creates a subnet CIDR reservation. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html">Subnet
   * CIDR reservations</a> in the <i>Amazon VPC User Guide</i> and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-prefixes.html">Manage
   * prefixes for your network interfaces</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnetCidrReservation">AWS
   * API Reference</a></p>
   */
  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 <typename CreateSubnetCidrReservationRequestT = Model::CreateSubnetCidrReservationRequest>
  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 <typename CreateSubnetCidrReservationRequestT = Model::CreateSubnetCidrReservationRequest>
  void CreateSubnetCidrReservationAsync(const CreateSubnetCidrReservationRequestT& request,
                                        const CreateSubnetCidrReservationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateSubnetCidrReservation, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information about tags, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
   * your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User
   * Guide</i>. For more information about creating IAM policies that control users'
   * access to resources based on tags, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-iam-actions-resources.html">Supported
   * resource-level permissions for Amazon EC2 API actions</a> in the <i>Amazon
   * Elastic Compute Cloud User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTags">AWS API
   * Reference</a></p>
   */
  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 <typename CreateTagsRequestT = Model::CreateTagsRequest>
  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 <typename CreateTagsRequestT = Model::CreateTagsRequest>
  void CreateTagsAsync(const CreateTagsRequestT& request, const CreateTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTags, request, handler, context);
  }

  /**
   * <p>Creates a Traffic Mirror filter.</p> <p>A Traffic Mirror filter is a set of
   * rules that defines the traffic to mirror.</p> <p>By default, no traffic is
   * mirrored. To mirror traffic, use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorFilterRule.htm">CreateTrafficMirrorFilterRule</a>
   * to add Traffic Mirror rules to the filter. The rules you add define what traffic
   * gets mirrored. You can also use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyTrafficMirrorFilterNetworkServices.html">ModifyTrafficMirrorFilterNetworkServices</a>
   * to mirror supported network services.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorFilter">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTrafficMirrorFilterRequestT = Model::CreateTrafficMirrorFilterRequest>
  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 <typename CreateTrafficMirrorFilterRequestT = Model::CreateTrafficMirrorFilterRequest>
  void CreateTrafficMirrorFilterAsync(const CreateTrafficMirrorFilterResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const CreateTrafficMirrorFilterRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateTrafficMirrorFilter, request, handler, context);
  }

  /**
   * <p>Creates a Traffic Mirror filter rule.</p> <p>A Traffic Mirror rule defines
   * the Traffic Mirror source traffic to mirror.</p> <p>You need the Traffic Mirror
   * filter ID when you create the rule.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorFilterRule">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTrafficMirrorFilterRuleRequestT = Model::CreateTrafficMirrorFilterRuleRequest>
  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 <typename CreateTrafficMirrorFilterRuleRequestT = Model::CreateTrafficMirrorFilterRuleRequest>
  void CreateTrafficMirrorFilterRuleAsync(const CreateTrafficMirrorFilterRuleRequestT& request,
                                          const CreateTrafficMirrorFilterRuleResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTrafficMirrorFilterRule, request, handler, context);
  }

  /**
   * <p>Creates a Traffic Mirror session.</p> <p>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.</p> <p>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. </p> <p>By
   * default, no traffic is mirrored. Use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorFilter.html">CreateTrafficMirrorFilter</a>
   * to create filter rules that specify the traffic to mirror.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorSession">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTrafficMirrorSessionRequestT = Model::CreateTrafficMirrorSessionRequest>
  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 <typename CreateTrafficMirrorSessionRequestT = Model::CreateTrafficMirrorSessionRequest>
  void CreateTrafficMirrorSessionAsync(const CreateTrafficMirrorSessionRequestT& request,
                                       const CreateTrafficMirrorSessionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTrafficMirrorSession, request, handler, context);
  }

  /**
   * <p>Creates a target for your Traffic Mirror session.</p> <p>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.</p> <p>A Traffic
   * Mirror target can be a network interface, a Network Load Balancer, or a Gateway
   * Load Balancer endpoint.</p> <p>To use the target in a Traffic Mirror session,
   * use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorSession.htm">CreateTrafficMirrorSession</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorTarget">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTrafficMirrorTargetRequestT = Model::CreateTrafficMirrorTargetRequest>
  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 <typename CreateTrafficMirrorTargetRequestT = Model::CreateTrafficMirrorTargetRequest>
  void CreateTrafficMirrorTargetAsync(const CreateTrafficMirrorTargetResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const CreateTrafficMirrorTargetRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateTrafficMirrorTarget, request, handler, context);
  }

  /**
   * <p>Creates a transit gateway.</p> <p>You can use a transit gateway to
   * interconnect your virtual private clouds (VPC) and on-premises networks. After
   * the transit gateway enters the <code>available</code> state, you can attach your
   * VPCs and VPN connections to the transit gateway.</p> <p>To attach your VPCs, use
   * <a>CreateTransitGatewayVpcAttachment</a>.</p> <p>To attach a VPN connection, use
   * <a>CreateCustomerGateway</a> to create a customer gateway and specify the ID of
   * the customer gateway and the ID of the transit gateway in a call to
   * <a>CreateVpnConnection</a>.</p> <p>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
   * <a>CreateTransitGatewayRouteTable</a> 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
   * <a>EnableTransitGatewayRouteTablePropagation</a> to propagate routes from a
   * resource attachment to a transit gateway route table. If you disable automatic
   * associations, you can use <a>AssociateTransitGatewayRouteTable</a> to associate
   * a resource attachment with a transit gateway route table.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGateway">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayRequestT = Model::CreateTransitGatewayRequest>
  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 <typename CreateTransitGatewayRequestT = Model::CreateTransitGatewayRequest>
  void CreateTransitGatewayAsync(const CreateTransitGatewayResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const CreateTransitGatewayRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateTransitGateway, request, handler, context);
  }

  /**
   * <p>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.</p> <p>A
   * Connect attachment uses an existing VPC or Amazon Web Services Direct Connect
   * attachment as the underlying transport mechanism.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayConnect">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayConnectRequestT = Model::CreateTransitGatewayConnectRequest>
  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 <typename CreateTransitGatewayConnectRequestT = Model::CreateTransitGatewayConnectRequest>
  void CreateTransitGatewayConnectAsync(const CreateTransitGatewayConnectRequestT& request,
                                        const CreateTransitGatewayConnectResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayConnect, request, handler, context);
  }

  /**
   * <p>Creates a Connect peer for a specified transit gateway Connect attachment
   * between a transit gateway and an appliance.</p> <p>The peer address and transit
   * gateway address must be the same IP address family (IPv4 or IPv6).</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html#tgw-connect-peer">Connect
   * peers</a> in the <i>Amazon Web Services Transit Gateways
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayConnectPeer">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayConnectPeerRequestT = Model::CreateTransitGatewayConnectPeerRequest>
  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 <typename CreateTransitGatewayConnectPeerRequestT = Model::CreateTransitGatewayConnectPeerRequest>
  void CreateTransitGatewayConnectPeerAsync(const CreateTransitGatewayConnectPeerRequestT& request,
                                            const CreateTransitGatewayConnectPeerResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayConnectPeer, request, handler, context);
  }

  /**
   * <p>Creates a metering policy for a transit gateway to track and measure network
   * traffic.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayMeteringPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateTransitGatewayMeteringPolicyOutcome CreateTransitGatewayMeteringPolicy(
      const Model::CreateTransitGatewayMeteringPolicyRequest& request) const;

  /**
   * A Callable wrapper for CreateTransitGatewayMeteringPolicy that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename CreateTransitGatewayMeteringPolicyRequestT = Model::CreateTransitGatewayMeteringPolicyRequest>
  Model::CreateTransitGatewayMeteringPolicyOutcomeCallable CreateTransitGatewayMeteringPolicyCallable(
      const CreateTransitGatewayMeteringPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayMeteringPolicy, request);
  }

  /**
   * An Async wrapper for CreateTransitGatewayMeteringPolicy that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename CreateTransitGatewayMeteringPolicyRequestT = Model::CreateTransitGatewayMeteringPolicyRequest>
  void CreateTransitGatewayMeteringPolicyAsync(const CreateTransitGatewayMeteringPolicyRequestT& request,
                                               const CreateTransitGatewayMeteringPolicyResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayMeteringPolicy, request, handler, context);
  }

  /**
   * <p>Creates an entry in a transit gateway metering policy to define traffic
   * measurement rules.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayMeteringPolicyEntry">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateTransitGatewayMeteringPolicyEntryOutcome CreateTransitGatewayMeteringPolicyEntry(
      const Model::CreateTransitGatewayMeteringPolicyEntryRequest& request) const;

  /**
   * A Callable wrapper for CreateTransitGatewayMeteringPolicyEntry that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename CreateTransitGatewayMeteringPolicyEntryRequestT = Model::CreateTransitGatewayMeteringPolicyEntryRequest>
  Model::CreateTransitGatewayMeteringPolicyEntryOutcomeCallable CreateTransitGatewayMeteringPolicyEntryCallable(
      const CreateTransitGatewayMeteringPolicyEntryRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayMeteringPolicyEntry, request);
  }

  /**
   * An Async wrapper for CreateTransitGatewayMeteringPolicyEntry that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename CreateTransitGatewayMeteringPolicyEntryRequestT = Model::CreateTransitGatewayMeteringPolicyEntryRequest>
  void CreateTransitGatewayMeteringPolicyEntryAsync(const CreateTransitGatewayMeteringPolicyEntryRequestT& request,
                                                    const CreateTransitGatewayMeteringPolicyEntryResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayMeteringPolicyEntry, request, handler, context);
  }

  /**
   * <p>Creates a multicast domain using the specified transit gateway.</p> <p>The
   * transit gateway must be in the available state before you create a domain. Use
   * <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeTransitGateways.html">DescribeTransitGateways</a>
   * to see the state of transit gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayMulticastDomain">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayMulticastDomainRequestT = Model::CreateTransitGatewayMulticastDomainRequest>
  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 <typename CreateTransitGatewayMulticastDomainRequestT = Model::CreateTransitGatewayMulticastDomainRequest>
  void CreateTransitGatewayMulticastDomainAsync(const CreateTransitGatewayMulticastDomainRequestT& request,
                                                const CreateTransitGatewayMulticastDomainResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayMulticastDomain, request, handler, context);
  }

  /**
   * <p>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.</p>
   * <p>After you create the peering attachment, the owner of the accepter transit
   * gateway must accept the attachment request.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPeeringAttachment">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayPeeringAttachmentRequestT = Model::CreateTransitGatewayPeeringAttachmentRequest>
  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 <typename CreateTransitGatewayPeeringAttachmentRequestT = Model::CreateTransitGatewayPeeringAttachmentRequest>
  void CreateTransitGatewayPeeringAttachmentAsync(const CreateTransitGatewayPeeringAttachmentRequestT& request,
                                                  const CreateTransitGatewayPeeringAttachmentResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayPeeringAttachment, request, handler, context);
  }

  /**
   * <p>Creates a transit gateway policy table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPolicyTable">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayPolicyTableRequestT = Model::CreateTransitGatewayPolicyTableRequest>
  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 <typename CreateTransitGatewayPolicyTableRequestT = Model::CreateTransitGatewayPolicyTableRequest>
  void CreateTransitGatewayPolicyTableAsync(const CreateTransitGatewayPolicyTableRequestT& request,
                                            const CreateTransitGatewayPolicyTableResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayPolicyTable, request, handler, context);
  }

  /**
   * <p>Creates a reference (route) to a prefix list in a specified transit gateway
   * route table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPrefixListReference">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayPrefixListReferenceRequestT = Model::CreateTransitGatewayPrefixListReferenceRequest>
  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 <typename CreateTransitGatewayPrefixListReferenceRequestT = Model::CreateTransitGatewayPrefixListReferenceRequest>
  void CreateTransitGatewayPrefixListReferenceAsync(const CreateTransitGatewayPrefixListReferenceRequestT& request,
                                                    const CreateTransitGatewayPrefixListReferenceResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayPrefixListReference, request, handler, context);
  }

  /**
   * <p>Creates a static route for the specified transit gateway route
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRoute">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayRouteRequestT = Model::CreateTransitGatewayRouteRequest>
  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 <typename CreateTransitGatewayRouteRequestT = Model::CreateTransitGatewayRouteRequest>
  void CreateTransitGatewayRouteAsync(const CreateTransitGatewayRouteRequestT& request,
                                      const CreateTransitGatewayRouteResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayRoute, request, handler, context);
  }

  /**
   * <p>Creates a route table for the specified transit gateway.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayRouteTableRequestT = Model::CreateTransitGatewayRouteTableRequest>
  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 <typename CreateTransitGatewayRouteTableRequestT = Model::CreateTransitGatewayRouteTableRequest>
  void CreateTransitGatewayRouteTableAsync(const CreateTransitGatewayRouteTableRequestT& request,
                                           const CreateTransitGatewayRouteTableResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayRouteTable, request, handler, context);
  }

  /**
   * <p>Advertises a new transit gateway route table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRouteTableAnnouncement">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayRouteTableAnnouncementRequestT = Model::CreateTransitGatewayRouteTableAnnouncementRequest>
  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 <typename CreateTransitGatewayRouteTableAnnouncementRequestT = Model::CreateTransitGatewayRouteTableAnnouncementRequest>
  void CreateTransitGatewayRouteTableAnnouncementAsync(
      const CreateTransitGatewayRouteTableAnnouncementRequestT& request,
      const CreateTransitGatewayRouteTableAnnouncementResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayRouteTableAnnouncement, request, handler, context);
  }

  /**
   * <p>Attaches the specified VPC to the specified transit gateway.</p> <p>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.</p> <p>To send VPC traffic to an attached transit
   * gateway, add a route to the VPC route table using
   * <a>CreateRoute</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayVpcAttachment">AWS
   * API Reference</a></p>
   */
  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 <typename CreateTransitGatewayVpcAttachmentRequestT = Model::CreateTransitGatewayVpcAttachmentRequest>
  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 <typename CreateTransitGatewayVpcAttachmentRequestT = Model::CreateTransitGatewayVpcAttachmentRequest>
  void CreateTransitGatewayVpcAttachmentAsync(const CreateTransitGatewayVpcAttachmentRequestT& request,
                                              const CreateTransitGatewayVpcAttachmentResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateTransitGatewayVpcAttachment, request, handler, context);
  }

  /**
   * <p>An Amazon Web Services Verified Access endpoint is where you define your
   * application along with an optional endpoint-level access policy.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVerifiedAccessEndpointRequestT = Model::CreateVerifiedAccessEndpointRequest>
  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 <typename CreateVerifiedAccessEndpointRequestT = Model::CreateVerifiedAccessEndpointRequest>
  void CreateVerifiedAccessEndpointAsync(const CreateVerifiedAccessEndpointRequestT& request,
                                         const CreateVerifiedAccessEndpointResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVerifiedAccessEndpoint, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessGroup">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVerifiedAccessGroupRequestT = Model::CreateVerifiedAccessGroupRequest>
  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 <typename CreateVerifiedAccessGroupRequestT = Model::CreateVerifiedAccessGroupRequest>
  void CreateVerifiedAccessGroupAsync(const CreateVerifiedAccessGroupRequestT& request,
                                      const CreateVerifiedAccessGroupResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVerifiedAccessGroup, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessInstance">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVerifiedAccessInstanceRequestT = Model::CreateVerifiedAccessInstanceRequest>
  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 <typename CreateVerifiedAccessInstanceRequestT = Model::CreateVerifiedAccessInstanceRequest>
  void CreateVerifiedAccessInstanceAsync(const CreateVerifiedAccessInstanceResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const CreateVerifiedAccessInstanceRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateVerifiedAccessInstance, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessTrustProvider">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVerifiedAccessTrustProviderRequestT = Model::CreateVerifiedAccessTrustProviderRequest>
  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 <typename CreateVerifiedAccessTrustProviderRequestT = Model::CreateVerifiedAccessTrustProviderRequest>
  void CreateVerifiedAccessTrustProviderAsync(const CreateVerifiedAccessTrustProviderRequestT& request,
                                              const CreateVerifiedAccessTrustProviderResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVerifiedAccessTrustProvider, request, handler, context);
  }

  /**
   * <p>Creates an EBS volume that can be attached to an instance in the same
   * Availability Zone.</p> <p>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.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html">Amazon
   * EBS encryption</a> in the <i>Amazon EBS User Guide</i>.</p> <p>You can tag your
   * volumes during creation. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
   * your Amazon EC2 resources</a> in the <i>Amazon EC2 User Guide</i>.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-creating-volume.html">Create
   * an Amazon EBS volume</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVolume">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVolumeRequestT = Model::CreateVolumeRequest>
  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 <typename CreateVolumeRequestT = Model::CreateVolumeRequest>
  void CreateVolumeAsync(const CreateVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const CreateVolumeRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateVolume, request, handler, context);
  }

  /**
   * <p>Creates a VPC with the specified CIDR blocks.</p> <p>A VPC must have an
   * associated IPv4 CIDR block. You can choose an IPv4 CIDR block or an
   * IPAM-allocated IPv4 CIDR block. You can optionally associate an IPv6 CIDR block
   * with a VPC. You can choose an IPv6 CIDR block, an Amazon-provided IPv6 CIDR
   * block, an IPAM-allocated IPv6 CIDR block, or an IPv6 CIDR block that you brought
   * to Amazon Web Services. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-ip-addressing.html">IP
   * addressing for your VPCs and subnets</a> in the <i>Amazon VPC User
   * Guide</i>.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP
   * option sets</a> in the <i>Amazon VPC User Guide</i>.</p> <p>You can specify DNS
   * options and tenancy for a VPC when you create it. You can't change the tenancy
   * of a VPC after you create it. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc-options.html">VPC
   * configuration options</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpc">AWS API
   * Reference</a></p>
   */
  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 <typename CreateVpcRequestT = Model::CreateVpcRequest>
  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 <typename CreateVpcRequestT = Model::CreateVpcRequest>
  void CreateVpcAsync(const CreateVpcResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const CreateVpcRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateVpc, request, handler, context);
  }

  /**
   * <p>Create a VPC Block Public Access (BPA) exclusion. A VPC BPA exclusion is a
   * mode that can be applied to a single VPC or subnet that exempts it from the
   * account’s BPA mode and will allow bidirectional or egress-only access. You can
   * create BPA exclusions for VPCs and subnets even when BPA is not enabled on the
   * account to ensure that there is no traffic disruption to the exclusions when VPC
   * BPA is turned on. To learn more about VPC BPA, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/security-vpc-bpa.html">Block
   * public access to VPCs and subnets</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcBlockPublicAccessExclusion">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateVpcBlockPublicAccessExclusionOutcome CreateVpcBlockPublicAccessExclusion(
      const Model::CreateVpcBlockPublicAccessExclusionRequest& request) const;

  /**
   * A Callable wrapper for CreateVpcBlockPublicAccessExclusion that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename CreateVpcBlockPublicAccessExclusionRequestT = Model::CreateVpcBlockPublicAccessExclusionRequest>
  Model::CreateVpcBlockPublicAccessExclusionOutcomeCallable CreateVpcBlockPublicAccessExclusionCallable(
      const CreateVpcBlockPublicAccessExclusionRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpcBlockPublicAccessExclusion, request);
  }

  /**
   * An Async wrapper for CreateVpcBlockPublicAccessExclusion that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename CreateVpcBlockPublicAccessExclusionRequestT = Model::CreateVpcBlockPublicAccessExclusionRequest>
  void CreateVpcBlockPublicAccessExclusionAsync(const CreateVpcBlockPublicAccessExclusionRequestT& request,
                                                const CreateVpcBlockPublicAccessExclusionResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVpcBlockPublicAccessExclusion, request, handler, context);
  }

  /**
   * <p>Creates a VPC Encryption Control configuration for a specified VPC. VPC
   * Encryption Control enables you to enforce encryption for all data in transit
   * within and between VPCs to meet compliance requirements for standards like
   * HIPAA, FedRAMP, and PCI DSS.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html">Enforce
   * VPC encryption in transit</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEncryptionControl">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateVpcEncryptionControlOutcome CreateVpcEncryptionControl(
      const Model::CreateVpcEncryptionControlRequest& request) const;

  /**
   * A Callable wrapper for CreateVpcEncryptionControl that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename CreateVpcEncryptionControlRequestT = Model::CreateVpcEncryptionControlRequest>
  Model::CreateVpcEncryptionControlOutcomeCallable CreateVpcEncryptionControlCallable(
      const CreateVpcEncryptionControlRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpcEncryptionControl, request);
  }

  /**
   * An Async wrapper for CreateVpcEncryptionControl that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename CreateVpcEncryptionControlRequestT = Model::CreateVpcEncryptionControlRequest>
  void CreateVpcEncryptionControlAsync(const CreateVpcEncryptionControlRequestT& request,
                                       const CreateVpcEncryptionControlResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVpcEncryptionControl, request, handler, context);
  }

  /**
   * <p>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
   * <a href="https://docs.aws.amazon.com/vpc/latest/privatelink/">Amazon Web
   * Services PrivateLink User Guide</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVpcEndpointRequestT = Model::CreateVpcEndpointRequest>
  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 <typename CreateVpcEndpointRequestT = Model::CreateVpcEndpointRequest>
  void CreateVpcEndpointAsync(const CreateVpcEndpointRequestT& request, const CreateVpcEndpointResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVpcEndpoint, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html">Creating an
   * Amazon SNS topic</a> in the <i>Amazon SNS Developer Guide</i>.</p> <p>You can
   * create a connection notification for interface endpoints only.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpointConnectionNotification">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVpcEndpointConnectionNotificationRequestT = Model::CreateVpcEndpointConnectionNotificationRequest>
  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 <typename CreateVpcEndpointConnectionNotificationRequestT = Model::CreateVpcEndpointConnectionNotificationRequest>
  void CreateVpcEndpointConnectionNotificationAsync(const CreateVpcEndpointConnectionNotificationRequestT& request,
                                                    const CreateVpcEndpointConnectionNotificationResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVpcEndpointConnectionNotification, request, handler, context);
  }

  /**
   * <p>Creates a VPC endpoint service to which service consumers (Amazon Web
   * Services accounts, users, and IAM roles) can connect.</p> <p>Before you create
   * an endpoint service, you must create one of the following for your service:</p>
   * <ul> <li> <p>A <a
   * href="https://docs.aws.amazon.com/elasticloadbalancing/latest/network/">Network
   * Load Balancer</a>. Service consumers connect to your service using an interface
   * endpoint.</p> </li> <li> <p>A <a
   * href="https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/">Gateway
   * Load Balancer</a>. Service consumers connect to your service using a Gateway
   * Load Balancer endpoint.</p> </li> </ul> <p>If you set the private DNS name, you
   * must prove that you own the private DNS domain name.</p> <p>For more
   * information, see the <a
   * href="https://docs.aws.amazon.com/vpc/latest/privatelink/">Amazon Web Services
   * PrivateLink Guide</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpointServiceConfiguration">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVpcEndpointServiceConfigurationRequestT = Model::CreateVpcEndpointServiceConfigurationRequest>
  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 <typename CreateVpcEndpointServiceConfigurationRequestT = Model::CreateVpcEndpointServiceConfigurationRequest>
  void CreateVpcEndpointServiceConfigurationAsync(const CreateVpcEndpointServiceConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const CreateVpcEndpointServiceConfigurationRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::CreateVpcEndpointServiceConfiguration, request, handler, context);
  }

  /**
   * <p>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.</p>  <p>Limitations and rules apply to a VPC
   * peering connection. For more information, see the <a
   * href="https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-basics.html#vpc-peering-limitations">VPC
   * peering limitations</a> in the <i>VPC Peering Guide</i>.</p>  <p>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.</p> <p>If you create a VPC
   * peering connection request between VPCs with overlapping CIDR blocks, the VPC
   * peering connection has a status of <code>failed</code>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcPeeringConnection">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVpcPeeringConnectionRequestT = Model::CreateVpcPeeringConnectionRequest>
  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 <typename CreateVpcPeeringConnectionRequestT = Model::CreateVpcPeeringConnectionRequest>
  void CreateVpcPeeringConnectionAsync(const CreateVpcPeeringConnectionRequestT& request,
                                       const CreateVpcPeeringConnectionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVpcPeeringConnection, request, handler, context);
  }

  /**
   * <p>Creates a VPN concentrator that aggregates multiple VPN connections to a
   * transit gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConcentrator">AWS
   * API Reference</a></p>
   */
  virtual Model::CreateVpnConcentratorOutcome CreateVpnConcentrator(const Model::CreateVpnConcentratorRequest& request) const;

  /**
   * A Callable wrapper for CreateVpnConcentrator that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename CreateVpnConcentratorRequestT = Model::CreateVpnConcentratorRequest>
  Model::CreateVpnConcentratorOutcomeCallable CreateVpnConcentratorCallable(const CreateVpnConcentratorRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpnConcentrator, request);
  }

  /**
   * An Async wrapper for CreateVpnConcentrator that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename CreateVpnConcentratorRequestT = Model::CreateVpnConcentratorRequest>
  void CreateVpnConcentratorAsync(const CreateVpnConcentratorRequestT& request, const CreateVpnConcentratorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVpnConcentrator, request, handler, context);
  }

  /**
   * <p>Creates a VPN connection between an existing virtual private gateway or
   * transit gateway and a customer gateway. The supported connection type is
   * <code>ipsec.1</code>.</p> <p>The response includes information that you need to
   * give to your network administrator to configure your customer gateway.</p>
   *  <p>We strongly recommend that you use HTTPS when calling this
   * operation because the response contains sensitive cryptographic information for
   * configuring your customer gateway device.</p>  <p>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.</p> <p>This is an idempotent operation. If you perform
   * the operation more than once, Amazon EC2 doesn't return an error.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web
   * Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnection">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVpnConnectionRequestT = Model::CreateVpnConnectionRequest>
  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 <typename CreateVpnConnectionRequestT = Model::CreateVpnConnectionRequest>
  void CreateVpnConnectionAsync(const CreateVpnConnectionRequestT& request, const CreateVpnConnectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVpnConnection, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web
   * Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnectionRoute">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVpnConnectionRouteRequestT = Model::CreateVpnConnectionRouteRequest>
  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 <typename CreateVpnConnectionRouteRequestT = Model::CreateVpnConnectionRouteRequest>
  void CreateVpnConnectionRouteAsync(const CreateVpnConnectionRouteRequestT& request,
                                     const CreateVpnConnectionRouteResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVpnConnectionRoute, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web
   * Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnGateway">AWS
   * API Reference</a></p>
   */
  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 <typename CreateVpnGatewayRequestT = Model::CreateVpnGatewayRequest>
  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 <typename CreateVpnGatewayRequestT = Model::CreateVpnGatewayRequest>
  void CreateVpnGatewayAsync(const CreateVpnGatewayRequestT& request, const CreateVpnGatewayResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateVpnGateway, request, handler, context);
  }

  /**
   * <p> Deletes an existing Capacity Manager data export configuration. This stops
   * future scheduled exports but does not delete previously exported files from S3.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCapacityManagerDataExport">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteCapacityManagerDataExportOutcome DeleteCapacityManagerDataExport(
      const Model::DeleteCapacityManagerDataExportRequest& request) const;

  /**
   * A Callable wrapper for DeleteCapacityManagerDataExport that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteCapacityManagerDataExportRequestT = Model::DeleteCapacityManagerDataExportRequest>
  Model::DeleteCapacityManagerDataExportOutcomeCallable DeleteCapacityManagerDataExportCallable(
      const DeleteCapacityManagerDataExportRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteCapacityManagerDataExport, request);
  }

  /**
   * An Async wrapper for DeleteCapacityManagerDataExport that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DeleteCapacityManagerDataExportRequestT = Model::DeleteCapacityManagerDataExportRequest>
  void DeleteCapacityManagerDataExportAsync(const DeleteCapacityManagerDataExportRequestT& request,
                                            const DeleteCapacityManagerDataExportResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteCapacityManagerDataExport, request, handler, context);
  }

  /**
   * <p>Deletes a carrier gateway.</p>  <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteRoute.html">DeleteRoute</a>.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCarrierGateway">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteCarrierGatewayRequestT = Model::DeleteCarrierGatewayRequest>
  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 <typename DeleteCarrierGatewayRequestT = Model::DeleteCarrierGatewayRequest>
  void DeleteCarrierGatewayAsync(const DeleteCarrierGatewayRequestT& request, const DeleteCarrierGatewayResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteCarrierGateway, request, handler, context);
  }

  /**
   * <p>Deletes the specified Client VPN endpoint. You must disassociate all target
   * networks before you can delete a Client VPN endpoint.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteClientVpnEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteClientVpnEndpointRequestT = Model::DeleteClientVpnEndpointRequest>
  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 <typename DeleteClientVpnEndpointRequestT = Model::DeleteClientVpnEndpointRequest>
  void DeleteClientVpnEndpointAsync(const DeleteClientVpnEndpointRequestT& request,
                                    const DeleteClientVpnEndpointResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteClientVpnEndpoint, request, handler, context);
  }

  /**
   * <p>Deletes a route from a Client VPN endpoint. You can only delete routes that
   * you manually added using the <b>CreateClientVpnRoute</b> 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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteClientVpnRoute">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteClientVpnRouteRequestT = Model::DeleteClientVpnRouteRequest>
  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 <typename DeleteClientVpnRouteRequestT = Model::DeleteClientVpnRouteRequest>
  void DeleteClientVpnRouteAsync(const DeleteClientVpnRouteRequestT& request, const DeleteClientVpnRouteResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteClientVpnRoute, request, handler, context);
  }

  /**
   * <p> Deletes a range of customer-owned IP addresses. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCoipCidr">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteCoipCidrRequestT = Model::DeleteCoipCidrRequest>
  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 <typename DeleteCoipCidrRequestT = Model::DeleteCoipCidrRequest>
  void DeleteCoipCidrAsync(const DeleteCoipCidrRequestT& request, const DeleteCoipCidrResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteCoipCidr, request, handler, context);
  }

  /**
   * <p>Deletes a pool of customer-owned IP (CoIP) addresses. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCoipPool">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteCoipPoolRequestT = Model::DeleteCoipPoolRequest>
  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 <typename DeleteCoipPoolRequestT = Model::DeleteCoipPoolRequest>
  void DeleteCoipPoolAsync(const DeleteCoipPoolRequestT& request, const DeleteCoipPoolResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteCoipPool, request, handler, context);
  }

  /**
   * <p>Deletes the specified customer gateway. You must delete the VPN connection
   * before you can delete the customer gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCustomerGateway">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteCustomerGatewayRequestT = Model::DeleteCustomerGatewayRequest>
  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 <typename DeleteCustomerGatewayRequestT = Model::DeleteCustomerGatewayRequest>
  void DeleteCustomerGatewayAsync(const DeleteCustomerGatewayRequestT& request, const DeleteCustomerGatewayResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteCustomerGateway, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteDhcpOptions">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteDhcpOptionsRequestT = Model::DeleteDhcpOptionsRequest>
  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 <typename DeleteDhcpOptionsRequestT = Model::DeleteDhcpOptionsRequest>
  void DeleteDhcpOptionsAsync(const DeleteDhcpOptionsRequestT& request, const DeleteDhcpOptionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteDhcpOptions, request, handler, context);
  }

  /**
   * <p>Deletes an egress-only internet gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteEgressOnlyInternetGateway">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteEgressOnlyInternetGatewayRequestT = Model::DeleteEgressOnlyInternetGatewayRequest>
  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 <typename DeleteEgressOnlyInternetGatewayRequestT = Model::DeleteEgressOnlyInternetGatewayRequest>
  void DeleteEgressOnlyInternetGatewayAsync(const DeleteEgressOnlyInternetGatewayRequestT& request,
                                            const DeleteEgressOnlyInternetGatewayResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteEgressOnlyInternetGateway, request, handler, context);
  }

  /**
   * <p>Deletes the specified EC2 Fleet request.</p> <p>After you delete an EC2 Fleet
   * request, it launches no new instances.</p> <p>You must also specify whether a
   * deleted EC2 Fleet request should terminate its instances. If you choose to
   * terminate the instances, the EC2 Fleet request enters the
   * <code>deleted_terminating</code> state. Otherwise, it enters the
   * <code>deleted_running</code> state, and the instances continue to run until they
   * are interrupted or you terminate them manually.</p> <p>A deleted
   * <code>instant</code> fleet with running instances is not supported. When you
   * delete an <code>instant</code> fleet, Amazon EC2 automatically terminates all
   * its instances. For fleets with more than 1000 instances, the deletion request
   * might fail. If your fleet has more than 1000 instances, first terminate most of
   * the instances manually, leaving 1000 or fewer. Then delete the fleet, and the
   * remaining instances will be terminated automatically.</p>  <p>
   * <b>Terminating an instance is permanent and irreversible.</b> </p> <p>After you
   * terminate an instance, you can no longer connect to it, and it can't be
   * recovered. All attached Amazon EBS volumes that are configured to be deleted on
   * termination are also permanently deleted and can't be recovered. All data stored
   * on instance store volumes is permanently lost. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-ec2-instance-termination-works.html">
   * How instance termination works</a>.</p> <p>Before you terminate an instance,
   * ensure that you have backed up all data that you need to retain after the
   * termination to persistent storage.</p>  <p class="title">
   * <b>Restrictions</b> </p> <ul> <li> <p>You can delete up to 25 fleets of type
   * <code>instant</code> in a single request.</p> </li> <li> <p>You can delete up to
   * 100 fleets of type <code>maintain</code> or <code>request</code> in a single
   * request.</p> </li> <li> <p>You can delete up to 125 fleets in a single request,
   * provided you do not exceed the quota for each fleet type, as specified
   * above.</p> </li> <li> <p>If you exceed the specified number of fleets to delete,
   * no fleets are deleted.</p> </li> </ul> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/delete-fleet.html">Delete
   * an EC2 Fleet request and the instances in the fleet</a> in the <i>Amazon EC2
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFleets">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteFleetsRequestT = Model::DeleteFleetsRequest>
  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 <typename DeleteFleetsRequestT = Model::DeleteFleetsRequest>
  void DeleteFleetsAsync(const DeleteFleetsRequestT& request, const DeleteFleetsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteFleets, request, handler, context);
  }

  /**
   * <p>Deletes one or more flow logs.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFlowLogs">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteFlowLogsRequestT = Model::DeleteFlowLogsRequest>
  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 <typename DeleteFlowLogsRequestT = Model::DeleteFlowLogsRequest>
  void DeleteFlowLogsAsync(const DeleteFlowLogsRequestT& request, const DeleteFlowLogsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteFlowLogs, request, handler, context);
  }

  /**
   * <p>Deletes the specified Amazon FPGA Image (AFI).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFpgaImage">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteFpgaImageRequestT = Model::DeleteFpgaImageRequest>
  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 <typename DeleteFpgaImageRequestT = Model::DeleteFpgaImageRequest>
  void DeleteFpgaImageAsync(const DeleteFpgaImageRequestT& request, const DeleteFpgaImageResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteFpgaImage, request, handler, context);
  }

  /**
   * <p>Deletes the specified image usage report.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/your-ec2-ami-usage.html">View
   * your AMI usage</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteImageUsageReport">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteImageUsageReportOutcome DeleteImageUsageReport(const Model::DeleteImageUsageReportRequest& request) const;

  /**
   * A Callable wrapper for DeleteImageUsageReport that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteImageUsageReportRequestT = Model::DeleteImageUsageReportRequest>
  Model::DeleteImageUsageReportOutcomeCallable DeleteImageUsageReportCallable(const DeleteImageUsageReportRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteImageUsageReport, request);
  }

  /**
   * An Async wrapper for DeleteImageUsageReport that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteImageUsageReportRequestT = Model::DeleteImageUsageReportRequest>
  void DeleteImageUsageReportAsync(const DeleteImageUsageReportRequestT& request,
                                   const DeleteImageUsageReportResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteImageUsageReport, request, handler, context);
  }

  /**
   * <p>Deletes the specified EC2 Instance Connect Endpoint.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInstanceConnectEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteInstanceConnectEndpointRequestT = Model::DeleteInstanceConnectEndpointRequest>
  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 <typename DeleteInstanceConnectEndpointRequestT = Model::DeleteInstanceConnectEndpointRequest>
  void DeleteInstanceConnectEndpointAsync(const DeleteInstanceConnectEndpointRequestT& request,
                                          const DeleteInstanceConnectEndpointResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteInstanceConnectEndpoint, request, handler, context);
  }

  /**
   * <p>Deletes the specified event window.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
   * event windows for scheduled events</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInstanceEventWindow">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteInstanceEventWindowRequestT = Model::DeleteInstanceEventWindowRequest>
  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 <typename DeleteInstanceEventWindowRequestT = Model::DeleteInstanceEventWindowRequest>
  void DeleteInstanceEventWindowAsync(const DeleteInstanceEventWindowRequestT& request,
                                      const DeleteInstanceEventWindowResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteInstanceEventWindow, request, handler, context);
  }

  /**
   * <p>Deletes the specified internet gateway. You must detach the internet gateway
   * from the VPC before you can delete it.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInternetGateway">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteInternetGatewayRequestT = Model::DeleteInternetGatewayRequest>
  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 <typename DeleteInternetGatewayRequestT = Model::DeleteInternetGatewayRequest>
  void DeleteInternetGatewayAsync(const DeleteInternetGatewayRequestT& request, const DeleteInternetGatewayResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteInternetGateway, request, handler, context);
  }

  /**
   * <p>Delete an IPAM. Deleting an IPAM removes all monitored data associated with
   * the IPAM including the historical data for CIDRs.</p> <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/delete-ipam.html">Delete an
   * IPAM</a> in the <i>Amazon VPC IPAM User Guide</i>. </p><p><h3>See Also:</h3>
   * <a href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpam">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteIpamRequestT = Model::DeleteIpamRequest>
  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 <typename DeleteIpamRequestT = Model::DeleteIpamRequest>
  void DeleteIpamAsync(const DeleteIpamRequestT& request, const DeleteIpamResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteIpam, request, handler, context);
  }

  /**
   * <p>Delete a verification token.</p> <p>A verification token is an Amazon Web
   * Services-generated random value that you can use to prove ownership of an
   * external resource. For example, you can use a verification token to validate
   * that you control a public IP address range when you bring an IP address range to
   * Amazon Web Services (BYOIP). </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamExternalResourceVerificationToken">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteIpamExternalResourceVerificationTokenOutcome DeleteIpamExternalResourceVerificationToken(
      const Model::DeleteIpamExternalResourceVerificationTokenRequest& request) const;

  /**
   * A Callable wrapper for DeleteIpamExternalResourceVerificationToken that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DeleteIpamExternalResourceVerificationTokenRequestT = Model::DeleteIpamExternalResourceVerificationTokenRequest>
  Model::DeleteIpamExternalResourceVerificationTokenOutcomeCallable DeleteIpamExternalResourceVerificationTokenCallable(
      const DeleteIpamExternalResourceVerificationTokenRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamExternalResourceVerificationToken, request);
  }

  /**
   * An Async wrapper for DeleteIpamExternalResourceVerificationToken that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DeleteIpamExternalResourceVerificationTokenRequestT = Model::DeleteIpamExternalResourceVerificationTokenRequest>
  void DeleteIpamExternalResourceVerificationTokenAsync(
      const DeleteIpamExternalResourceVerificationTokenRequestT& request,
      const DeleteIpamExternalResourceVerificationTokenResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteIpamExternalResourceVerificationToken, request, handler, context);
  }

  /**
   * <p>Deletes an IPAM policy.</p> <p>An IPAM policy is a set of rules that define
   * how public IPv4 addresses from IPAM pools are allocated to Amazon Web Services
   * resources. Each rule maps an Amazon Web Services service to IPAM pools that the
   * service will use to get IP addresses. A single policy can have multiple rules
   * and be applied to multiple Amazon Web Services Regions. If the IPAM pool run out
   * of addresses then the services fallback to Amazon-provided IP addresses. A
   * policy can be applied to an individual Amazon Web Services account or an entity
   * within Amazon Web Services Organizations.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteIpamPolicyOutcome DeleteIpamPolicy(const Model::DeleteIpamPolicyRequest& request) const;

  /**
   * A Callable wrapper for DeleteIpamPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteIpamPolicyRequestT = Model::DeleteIpamPolicyRequest>
  Model::DeleteIpamPolicyOutcomeCallable DeleteIpamPolicyCallable(const DeleteIpamPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamPolicy, request);
  }

  /**
   * An Async wrapper for DeleteIpamPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename DeleteIpamPolicyRequestT = Model::DeleteIpamPolicyRequest>
  void DeleteIpamPolicyAsync(const DeleteIpamPolicyRequestT& request, const DeleteIpamPolicyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteIpamPolicy, request, handler, context);
  }

  /**
   * <p>Delete an IPAM pool.</p>  <p>You cannot delete an IPAM pool if there
   * are allocations in it or CIDRs provisioned to it. To release allocations, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseIpamPoolAllocation.html">ReleaseIpamPoolAllocation</a>.
   * To deprovision pool CIDRs, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html">DeprovisionIpamPoolCidr</a>.</p>
   *  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/delete-pool-ipam.html">Delete
   * a pool</a> in the <i>Amazon VPC IPAM User Guide</i>. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamPool">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteIpamPoolRequestT = Model::DeleteIpamPoolRequest>
  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 <typename DeleteIpamPoolRequestT = Model::DeleteIpamPoolRequest>
  void DeleteIpamPoolAsync(const DeleteIpamPoolRequestT& request, const DeleteIpamPoolResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteIpamPool, request, handler, context);
  }

  /**
   * <p>Deletes an IPAM prefix list resolver. Before deleting a resolver, you must
   * first delete all resolver targets associated with it.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamPrefixListResolver">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteIpamPrefixListResolverOutcome DeleteIpamPrefixListResolver(
      const Model::DeleteIpamPrefixListResolverRequest& request) const;

  /**
   * A Callable wrapper for DeleteIpamPrefixListResolver that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteIpamPrefixListResolverRequestT = Model::DeleteIpamPrefixListResolverRequest>
  Model::DeleteIpamPrefixListResolverOutcomeCallable DeleteIpamPrefixListResolverCallable(
      const DeleteIpamPrefixListResolverRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamPrefixListResolver, request);
  }

  /**
   * An Async wrapper for DeleteIpamPrefixListResolver that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteIpamPrefixListResolverRequestT = Model::DeleteIpamPrefixListResolverRequest>
  void DeleteIpamPrefixListResolverAsync(const DeleteIpamPrefixListResolverRequestT& request,
                                         const DeleteIpamPrefixListResolverResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteIpamPrefixListResolver, request, handler, context);
  }

  /**
   * <p>Deletes an IPAM prefix list resolver target. This removes the association
   * between the resolver and the managed prefix list, stopping automatic CIDR
   * synchronization.</p> <p>For more information about IPAM prefix list resolver,
   * see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/automate-prefix-list-updates.html">Automate
   * prefix list updates with IPAM</a> in the <i>Amazon VPC IPAM User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamPrefixListResolverTarget">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteIpamPrefixListResolverTargetOutcome DeleteIpamPrefixListResolverTarget(
      const Model::DeleteIpamPrefixListResolverTargetRequest& request) const;

  /**
   * A Callable wrapper for DeleteIpamPrefixListResolverTarget that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DeleteIpamPrefixListResolverTargetRequestT = Model::DeleteIpamPrefixListResolverTargetRequest>
  Model::DeleteIpamPrefixListResolverTargetOutcomeCallable DeleteIpamPrefixListResolverTargetCallable(
      const DeleteIpamPrefixListResolverTargetRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamPrefixListResolverTarget, request);
  }

  /**
   * An Async wrapper for DeleteIpamPrefixListResolverTarget that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DeleteIpamPrefixListResolverTargetRequestT = Model::DeleteIpamPrefixListResolverTargetRequest>
  void DeleteIpamPrefixListResolverTargetAsync(const DeleteIpamPrefixListResolverTargetRequestT& request,
                                               const DeleteIpamPrefixListResolverTargetResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteIpamPrefixListResolverTarget, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamResourceDiscovery">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteIpamResourceDiscoveryRequestT = Model::DeleteIpamResourceDiscoveryRequest>
  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 <typename DeleteIpamResourceDiscoveryRequestT = Model::DeleteIpamResourceDiscoveryRequest>
  void DeleteIpamResourceDiscoveryAsync(const DeleteIpamResourceDiscoveryRequestT& request,
                                        const DeleteIpamResourceDiscoveryResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteIpamResourceDiscovery, request, handler, context);
  }

  /**
   * <p>Delete the scope for an IPAM. You cannot delete the default scopes.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/delete-scope-ipam.html">Delete
   * a scope</a> in the <i>Amazon VPC IPAM User Guide</i>. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamScope">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteIpamScopeRequestT = Model::DeleteIpamScopeRequest>
  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 <typename DeleteIpamScopeRequestT = Model::DeleteIpamScopeRequest>
  void DeleteIpamScopeAsync(const DeleteIpamScopeRequestT& request, const DeleteIpamScopeResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteIpamScope, request, handler, context);
  }

  /**
   * <p>Deletes the specified key pair, by removing the public key from Amazon
   * EC2.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteKeyPair">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
  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 <typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
  void DeleteKeyPairAsync(const DeleteKeyPairResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const DeleteKeyPairRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DeleteKeyPair, request, handler, context);
  }

  /**
   * <p>Deletes a launch template. Deleting a launch template deletes all of its
   * versions.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLaunchTemplate">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteLaunchTemplateRequestT = Model::DeleteLaunchTemplateRequest>
  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 <typename DeleteLaunchTemplateRequestT = Model::DeleteLaunchTemplateRequest>
  void DeleteLaunchTemplateAsync(const DeleteLaunchTemplateResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DeleteLaunchTemplateRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DeleteLaunchTemplate, request, handler, context);
  }

  /**
   * <p>Deletes one or more versions of a launch template.</p> <p>You can't 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
   * <a>DeleteLaunchTemplate</a>.</p> <p>You can delete up to 200 launch template
   * versions in a single request. To delete more than 200 versions in a single
   * request, use <a>DeleteLaunchTemplate</a>, which deletes the launch template and
   * all of its versions.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/delete-launch-template.html#delete-launch-template-version">Delete
   * a launch template version</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLaunchTemplateVersions">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteLaunchTemplateVersionsRequestT = Model::DeleteLaunchTemplateVersionsRequest>
  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 <typename DeleteLaunchTemplateVersionsRequestT = Model::DeleteLaunchTemplateVersionsRequest>
  void DeleteLaunchTemplateVersionsAsync(const DeleteLaunchTemplateVersionsRequestT& request,
                                         const DeleteLaunchTemplateVersionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteLaunchTemplateVersions, request, handler, context);
  }

  /**
   * <p>Deletes the specified route from the specified local gateway route
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRoute">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteLocalGatewayRouteRequestT = Model::DeleteLocalGatewayRouteRequest>
  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 <typename DeleteLocalGatewayRouteRequestT = Model::DeleteLocalGatewayRouteRequest>
  void DeleteLocalGatewayRouteAsync(const DeleteLocalGatewayRouteRequestT& request,
                                    const DeleteLocalGatewayRouteResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteLocalGatewayRoute, request, handler, context);
  }

  /**
   * <p> Deletes a local gateway route table. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteLocalGatewayRouteTableRequestT = Model::DeleteLocalGatewayRouteTableRequest>
  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 <typename DeleteLocalGatewayRouteTableRequestT = Model::DeleteLocalGatewayRouteTableRequest>
  void DeleteLocalGatewayRouteTableAsync(const DeleteLocalGatewayRouteTableRequestT& request,
                                         const DeleteLocalGatewayRouteTableResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteLocalGatewayRouteTable, request, handler, context);
  }

  /**
   * <p> Deletes a local gateway route table virtual interface group association.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT =
                Model::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest>
  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 <typename DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT =
                Model::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest>
  void DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationAsync(
      const DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT& request,
      const DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation, request, handler, context);
  }

  /**
   * <p>Deletes the specified association between a VPC and local gateway route
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTableVpcAssociation">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteLocalGatewayRouteTableVpcAssociationRequestT = Model::DeleteLocalGatewayRouteTableVpcAssociationRequest>
  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 <typename DeleteLocalGatewayRouteTableVpcAssociationRequestT = Model::DeleteLocalGatewayRouteTableVpcAssociationRequest>
  void DeleteLocalGatewayRouteTableVpcAssociationAsync(
      const DeleteLocalGatewayRouteTableVpcAssociationRequestT& request,
      const DeleteLocalGatewayRouteTableVpcAssociationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteLocalGatewayRouteTableVpcAssociation, request, handler, context);
  }

  /**
   * <p>Deletes the specified local gateway virtual interface.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayVirtualInterface">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteLocalGatewayVirtualInterfaceOutcome DeleteLocalGatewayVirtualInterface(
      const Model::DeleteLocalGatewayVirtualInterfaceRequest& request) const;

  /**
   * A Callable wrapper for DeleteLocalGatewayVirtualInterface that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DeleteLocalGatewayVirtualInterfaceRequestT = Model::DeleteLocalGatewayVirtualInterfaceRequest>
  Model::DeleteLocalGatewayVirtualInterfaceOutcomeCallable DeleteLocalGatewayVirtualInterfaceCallable(
      const DeleteLocalGatewayVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteLocalGatewayVirtualInterface, request);
  }

  /**
   * An Async wrapper for DeleteLocalGatewayVirtualInterface that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DeleteLocalGatewayVirtualInterfaceRequestT = Model::DeleteLocalGatewayVirtualInterfaceRequest>
  void DeleteLocalGatewayVirtualInterfaceAsync(const DeleteLocalGatewayVirtualInterfaceRequestT& request,
                                               const DeleteLocalGatewayVirtualInterfaceResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteLocalGatewayVirtualInterface, request, handler, context);
  }

  /**
   * <p>Delete the specified local gateway interface group.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayVirtualInterfaceGroup">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteLocalGatewayVirtualInterfaceGroupOutcome DeleteLocalGatewayVirtualInterfaceGroup(
      const Model::DeleteLocalGatewayVirtualInterfaceGroupRequest& request) const;

  /**
   * A Callable wrapper for DeleteLocalGatewayVirtualInterfaceGroup that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DeleteLocalGatewayVirtualInterfaceGroupRequestT = Model::DeleteLocalGatewayVirtualInterfaceGroupRequest>
  Model::DeleteLocalGatewayVirtualInterfaceGroupOutcomeCallable DeleteLocalGatewayVirtualInterfaceGroupCallable(
      const DeleteLocalGatewayVirtualInterfaceGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteLocalGatewayVirtualInterfaceGroup, request);
  }

  /**
   * An Async wrapper for DeleteLocalGatewayVirtualInterfaceGroup that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DeleteLocalGatewayVirtualInterfaceGroupRequestT = Model::DeleteLocalGatewayVirtualInterfaceGroupRequest>
  void DeleteLocalGatewayVirtualInterfaceGroupAsync(const DeleteLocalGatewayVirtualInterfaceGroupRequestT& request,
                                                    const DeleteLocalGatewayVirtualInterfaceGroupResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteLocalGatewayVirtualInterfaceGroup, request, handler, context);
  }

  /**
   * <p>Deletes the specified managed prefix list. You must first remove all
   * references to the prefix list in your resources.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteManagedPrefixList">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteManagedPrefixListRequestT = Model::DeleteManagedPrefixListRequest>
  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 <typename DeleteManagedPrefixListRequestT = Model::DeleteManagedPrefixListRequest>
  void DeleteManagedPrefixListAsync(const DeleteManagedPrefixListRequestT& request,
                                    const DeleteManagedPrefixListResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteManagedPrefixList, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNatGateway">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteNatGatewayRequestT = Model::DeleteNatGatewayRequest>
  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 <typename DeleteNatGatewayRequestT = Model::DeleteNatGatewayRequest>
  void DeleteNatGatewayAsync(const DeleteNatGatewayRequestT& request, const DeleteNatGatewayResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteNatGateway, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAcl">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteNetworkAclRequestT = Model::DeleteNetworkAclRequest>
  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 <typename DeleteNetworkAclRequestT = Model::DeleteNetworkAclRequest>
  void DeleteNetworkAclAsync(const DeleteNetworkAclRequestT& request, const DeleteNetworkAclResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteNetworkAcl, request, handler, context);
  }

  /**
   * <p>Deletes the specified ingress or egress entry (rule) from the specified
   * network ACL.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAclEntry">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteNetworkAclEntryRequestT = Model::DeleteNetworkAclEntryRequest>
  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 <typename DeleteNetworkAclEntryRequestT = Model::DeleteNetworkAclEntryRequest>
  void DeleteNetworkAclEntryAsync(const DeleteNetworkAclEntryRequestT& request, const DeleteNetworkAclEntryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteNetworkAclEntry, request, handler, context);
  }

  /**
   * <p>Deletes the specified Network Access Scope.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAccessScope">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteNetworkInsightsAccessScopeRequestT = Model::DeleteNetworkInsightsAccessScopeRequest>
  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 <typename DeleteNetworkInsightsAccessScopeRequestT = Model::DeleteNetworkInsightsAccessScopeRequest>
  void DeleteNetworkInsightsAccessScopeAsync(const DeleteNetworkInsightsAccessScopeRequestT& request,
                                             const DeleteNetworkInsightsAccessScopeResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteNetworkInsightsAccessScope, request, handler, context);
  }

  /**
   * <p>Deletes the specified Network Access Scope analysis.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAccessScopeAnalysis">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteNetworkInsightsAccessScopeAnalysisRequestT = Model::DeleteNetworkInsightsAccessScopeAnalysisRequest>
  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 <typename DeleteNetworkInsightsAccessScopeAnalysisRequestT = Model::DeleteNetworkInsightsAccessScopeAnalysisRequest>
  void DeleteNetworkInsightsAccessScopeAnalysisAsync(
      const DeleteNetworkInsightsAccessScopeAnalysisRequestT& request,
      const DeleteNetworkInsightsAccessScopeAnalysisResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteNetworkInsightsAccessScopeAnalysis, request, handler, context);
  }

  /**
   * <p>Deletes the specified network insights analysis.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAnalysis">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteNetworkInsightsAnalysisRequestT = Model::DeleteNetworkInsightsAnalysisRequest>
  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 <typename DeleteNetworkInsightsAnalysisRequestT = Model::DeleteNetworkInsightsAnalysisRequest>
  void DeleteNetworkInsightsAnalysisAsync(const DeleteNetworkInsightsAnalysisRequestT& request,
                                          const DeleteNetworkInsightsAnalysisResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteNetworkInsightsAnalysis, request, handler, context);
  }

  /**
   * <p>Deletes the specified path.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsPath">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteNetworkInsightsPathRequestT = Model::DeleteNetworkInsightsPathRequest>
  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 <typename DeleteNetworkInsightsPathRequestT = Model::DeleteNetworkInsightsPathRequest>
  void DeleteNetworkInsightsPathAsync(const DeleteNetworkInsightsPathRequestT& request,
                                      const DeleteNetworkInsightsPathResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteNetworkInsightsPath, request, handler, context);
  }

  /**
   * <p>Deletes the specified network interface. You must detach the network
   * interface before you can delete it.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterface">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteNetworkInterfaceRequestT = Model::DeleteNetworkInterfaceRequest>
  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 <typename DeleteNetworkInterfaceRequestT = Model::DeleteNetworkInterfaceRequest>
  void DeleteNetworkInterfaceAsync(const DeleteNetworkInterfaceRequestT& request,
                                   const DeleteNetworkInterfaceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteNetworkInterface, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterfacePermission">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteNetworkInterfacePermissionRequestT = Model::DeleteNetworkInterfacePermissionRequest>
  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 <typename DeleteNetworkInterfacePermissionRequestT = Model::DeleteNetworkInterfacePermissionRequest>
  void DeleteNetworkInterfacePermissionAsync(const DeleteNetworkInterfacePermissionRequestT& request,
                                             const DeleteNetworkInterfacePermissionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteNetworkInterfacePermission, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">Placement
   * groups</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePlacementGroup">AWS
   * API Reference</a></p>
   */
  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 <typename DeletePlacementGroupRequestT = Model::DeletePlacementGroupRequest>
  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 <typename DeletePlacementGroupRequestT = Model::DeletePlacementGroupRequest>
  void DeletePlacementGroupAsync(const DeletePlacementGroupRequestT& request, const DeletePlacementGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeletePlacementGroup, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePublicIpv4Pool">AWS
   * API Reference</a></p>
   */
  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 <typename DeletePublicIpv4PoolRequestT = Model::DeletePublicIpv4PoolRequest>
  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 <typename DeletePublicIpv4PoolRequestT = Model::DeletePublicIpv4PoolRequest>
  void DeletePublicIpv4PoolAsync(const DeletePublicIpv4PoolRequestT& request, const DeletePublicIpv4PoolResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeletePublicIpv4Pool, request, handler, context);
  }

  /**
   * <p>Deletes the queued purchases for the specified Reserved
   * Instances.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteQueuedReservedInstances">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteQueuedReservedInstancesRequestT = Model::DeleteQueuedReservedInstancesRequest>
  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 <typename DeleteQueuedReservedInstancesRequestT = Model::DeleteQueuedReservedInstancesRequest>
  void DeleteQueuedReservedInstancesAsync(const DeleteQueuedReservedInstancesRequestT& request,
                                          const DeleteQueuedReservedInstancesResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteQueuedReservedInstances, request, handler, context);
  }

  /**
   * <p>Deletes the specified route from the specified route table.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRoute">AWS API
   * Reference</a></p>
   */
  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 <typename DeleteRouteRequestT = Model::DeleteRouteRequest>
  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 <typename DeleteRouteRequestT = Model::DeleteRouteRequest>
  void DeleteRouteAsync(const DeleteRouteRequestT& request, const DeleteRouteResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteRoute, request, handler, context);
  }

  /**
   * <p>Deletes the specified route server.</p> <p>Amazon VPC Route Server simplifies
   * routing for traffic between workloads that are deployed within a VPC and its
   * internet gateways. With this feature, VPC Route Server dynamically updates VPC
   * and internet gateway route tables with your preferred IPv4 or IPv6 routes to
   * achieve routing fault tolerance for those workloads. This enables you to
   * automatically reroute traffic within a VPC, which increases the manageability of
   * VPC routing and interoperability with third-party workloads.</p> <p>Route server
   * supports the follow route table types:</p> <ul> <li> <p>VPC route tables not
   * associated with subnets</p> </li> <li> <p>Subnet route tables</p> </li> <li>
   * <p>Internet gateway route tables</p> </li> </ul> <p>Route server does not
   * support route tables associated with virtual private gateways. To propagate
   * routes into a transit gateway route table, use <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html">Transit
   * Gateway Connect</a>.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRouteServer">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteRouteServerOutcome DeleteRouteServer(const Model::DeleteRouteServerRequest& request) const;

  /**
   * A Callable wrapper for DeleteRouteServer that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteRouteServerRequestT = Model::DeleteRouteServerRequest>
  Model::DeleteRouteServerOutcomeCallable DeleteRouteServerCallable(const DeleteRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteRouteServer, request);
  }

  /**
   * An Async wrapper for DeleteRouteServer that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename DeleteRouteServerRequestT = Model::DeleteRouteServerRequest>
  void DeleteRouteServerAsync(const DeleteRouteServerRequestT& request, const DeleteRouteServerResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteRouteServer, request, handler, context);
  }

  /**
   * <p>Deletes the specified route server endpoint.</p> <p>A route server endpoint
   * is an Amazon Web Services-managed component inside a subnet that facilitates <a
   * href="https://en.wikipedia.org/wiki/Border_Gateway_Protocol">BGP (Border Gateway
   * Protocol)</a> connections between your route server and your BGP
   * peers.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRouteServerEndpoint">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteRouteServerEndpointOutcome DeleteRouteServerEndpoint(const Model::DeleteRouteServerEndpointRequest& request) const;

  /**
   * A Callable wrapper for DeleteRouteServerEndpoint that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteRouteServerEndpointRequestT = Model::DeleteRouteServerEndpointRequest>
  Model::DeleteRouteServerEndpointOutcomeCallable DeleteRouteServerEndpointCallable(
      const DeleteRouteServerEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteRouteServerEndpoint, request);
  }

  /**
   * An Async wrapper for DeleteRouteServerEndpoint that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteRouteServerEndpointRequestT = Model::DeleteRouteServerEndpointRequest>
  void DeleteRouteServerEndpointAsync(const DeleteRouteServerEndpointRequestT& request,
                                      const DeleteRouteServerEndpointResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteRouteServerEndpoint, request, handler, context);
  }

  /**
   * <p>Deletes the specified BGP peer from a route server.</p> <p>A route server
   * peer is a session between a route server endpoint and the device deployed in
   * Amazon Web Services (such as a firewall appliance or other network security
   * function running on an EC2 instance). The device must meet these
   * requirements:</p> <ul> <li> <p>Have an elastic network interface in the VPC</p>
   * </li> <li> <p>Support BGP (Border Gateway Protocol)</p> </li> <li> <p>Can
   * initiate BGP sessions</p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRouteServerPeer">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteRouteServerPeerOutcome DeleteRouteServerPeer(const Model::DeleteRouteServerPeerRequest& request) const;

  /**
   * A Callable wrapper for DeleteRouteServerPeer that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteRouteServerPeerRequestT = Model::DeleteRouteServerPeerRequest>
  Model::DeleteRouteServerPeerOutcomeCallable DeleteRouteServerPeerCallable(const DeleteRouteServerPeerRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteRouteServerPeer, request);
  }

  /**
   * An Async wrapper for DeleteRouteServerPeer that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteRouteServerPeerRequestT = Model::DeleteRouteServerPeerRequest>
  void DeleteRouteServerPeerAsync(const DeleteRouteServerPeerRequestT& request, const DeleteRouteServerPeerResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteRouteServerPeer, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteRouteTableRequestT = Model::DeleteRouteTableRequest>
  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 <typename DeleteRouteTableRequestT = Model::DeleteRouteTableRequest>
  void DeleteRouteTableAsync(const DeleteRouteTableRequestT& request, const DeleteRouteTableResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteRouteTable, request, handler, context);
  }

  /**
   * <p>Deletes a secondary network. You must delete all secondary subnets in the
   * secondary network before you can delete the secondary network.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSecondaryNetwork">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteSecondaryNetworkOutcome DeleteSecondaryNetwork(const Model::DeleteSecondaryNetworkRequest& request) const;

  /**
   * A Callable wrapper for DeleteSecondaryNetwork that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteSecondaryNetworkRequestT = Model::DeleteSecondaryNetworkRequest>
  Model::DeleteSecondaryNetworkOutcomeCallable DeleteSecondaryNetworkCallable(const DeleteSecondaryNetworkRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteSecondaryNetwork, request);
  }

  /**
   * An Async wrapper for DeleteSecondaryNetwork that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteSecondaryNetworkRequestT = Model::DeleteSecondaryNetworkRequest>
  void DeleteSecondaryNetworkAsync(const DeleteSecondaryNetworkRequestT& request,
                                   const DeleteSecondaryNetworkResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteSecondaryNetwork, request, handler, context);
  }

  /**
   * <p>Deletes a secondary subnet. A secondary subnet must not contain any secondary
   * interfaces prior to deletion.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSecondarySubnet">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteSecondarySubnetOutcome DeleteSecondarySubnet(const Model::DeleteSecondarySubnetRequest& request) const;

  /**
   * A Callable wrapper for DeleteSecondarySubnet that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteSecondarySubnetRequestT = Model::DeleteSecondarySubnetRequest>
  Model::DeleteSecondarySubnetOutcomeCallable DeleteSecondarySubnetCallable(const DeleteSecondarySubnetRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteSecondarySubnet, request);
  }

  /**
   * An Async wrapper for DeleteSecondarySubnet that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteSecondarySubnetRequestT = Model::DeleteSecondarySubnetRequest>
  void DeleteSecondarySubnetAsync(const DeleteSecondarySubnetRequestT& request, const DeleteSecondarySubnetResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteSecondarySubnet, request, handler, context);
  }

  /**
   * <p>Deletes a security group.</p> <p>If you attempt to delete a security group
   * that is associated with an instance or network interface, is referenced by
   * another security group in the same VPC, or has a VPC association, the operation
   * fails with <code>DependencyViolation</code>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSecurityGroup">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteSecurityGroupRequestT = Model::DeleteSecurityGroupRequest>
  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 <typename DeleteSecurityGroupRequestT = Model::DeleteSecurityGroupRequest>
  void DeleteSecurityGroupAsync(const DeleteSecurityGroupResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DeleteSecurityGroupRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DeleteSecurityGroup, request, handler, context);
  }

  /**
   * <p>Deletes the specified snapshot.</p> <p>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.</p> <p>You
   * cannot delete a snapshot of the root device of an EBS volume used by a
   * registered AMI. You must first deregister the AMI before you can delete the
   * snapshot.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-deleting-snapshot.html">Delete
   * an Amazon EBS snapshot</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSnapshot">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
  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 <typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
  void DeleteSnapshotAsync(const DeleteSnapshotRequestT& request, const DeleteSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteSnapshot, request, handler, context);
  }

  /**
   * <p>Deletes the data feed for Spot Instances.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSpotDatafeedSubscription">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteSpotDatafeedSubscriptionRequestT = Model::DeleteSpotDatafeedSubscriptionRequest>
  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 <typename DeleteSpotDatafeedSubscriptionRequestT = Model::DeleteSpotDatafeedSubscriptionRequest>
  void DeleteSpotDatafeedSubscriptionAsync(const DeleteSpotDatafeedSubscriptionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DeleteSpotDatafeedSubscriptionRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DeleteSpotDatafeedSubscription, request, handler, context);
  }

  /**
   * <p>Deletes the specified subnet. You must terminate all running instances in the
   * subnet before you can delete the subnet.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnet">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteSubnetRequestT = Model::DeleteSubnetRequest>
  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 <typename DeleteSubnetRequestT = Model::DeleteSubnetRequest>
  void DeleteSubnetAsync(const DeleteSubnetRequestT& request, const DeleteSubnetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteSubnet, request, handler, context);
  }

  /**
   * <p>Deletes a subnet CIDR reservation.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnetCidrReservation">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteSubnetCidrReservationRequestT = Model::DeleteSubnetCidrReservationRequest>
  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 <typename DeleteSubnetCidrReservationRequestT = Model::DeleteSubnetCidrReservationRequest>
  void DeleteSubnetCidrReservationAsync(const DeleteSubnetCidrReservationRequestT& request,
                                        const DeleteSubnetCidrReservationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteSubnetCidrReservation, request, handler, context);
  }

  /**
   * <p>Deletes the specified set of tags from the specified set of resources.</p>
   * <p>To list the current tags, use <a>DescribeTags</a>. For more information about
   * tags, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
   * your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTags">AWS API
   * Reference</a></p>
   */
  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 <typename DeleteTagsRequestT = Model::DeleteTagsRequest>
  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 <typename DeleteTagsRequestT = Model::DeleteTagsRequest>
  void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTags, request, handler, context);
  }

  /**
   * <p>Deletes the specified Traffic Mirror filter.</p> <p>You cannot delete a
   * Traffic Mirror filter that is in use by a Traffic Mirror session.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorFilter">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTrafficMirrorFilterRequestT = Model::DeleteTrafficMirrorFilterRequest>
  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 <typename DeleteTrafficMirrorFilterRequestT = Model::DeleteTrafficMirrorFilterRequest>
  void DeleteTrafficMirrorFilterAsync(const DeleteTrafficMirrorFilterRequestT& request,
                                      const DeleteTrafficMirrorFilterResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTrafficMirrorFilter, request, handler, context);
  }

  /**
   * <p>Deletes the specified Traffic Mirror rule.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorFilterRule">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTrafficMirrorFilterRuleRequestT = Model::DeleteTrafficMirrorFilterRuleRequest>
  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 <typename DeleteTrafficMirrorFilterRuleRequestT = Model::DeleteTrafficMirrorFilterRuleRequest>
  void DeleteTrafficMirrorFilterRuleAsync(const DeleteTrafficMirrorFilterRuleRequestT& request,
                                          const DeleteTrafficMirrorFilterRuleResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTrafficMirrorFilterRule, request, handler, context);
  }

  /**
   * <p>Deletes the specified Traffic Mirror session.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorSession">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTrafficMirrorSessionRequestT = Model::DeleteTrafficMirrorSessionRequest>
  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 <typename DeleteTrafficMirrorSessionRequestT = Model::DeleteTrafficMirrorSessionRequest>
  void DeleteTrafficMirrorSessionAsync(const DeleteTrafficMirrorSessionRequestT& request,
                                       const DeleteTrafficMirrorSessionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTrafficMirrorSession, request, handler, context);
  }

  /**
   * <p>Deletes the specified Traffic Mirror target.</p> <p>You cannot delete a
   * Traffic Mirror target that is in use by a Traffic Mirror session.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorTarget">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTrafficMirrorTargetRequestT = Model::DeleteTrafficMirrorTargetRequest>
  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 <typename DeleteTrafficMirrorTargetRequestT = Model::DeleteTrafficMirrorTargetRequest>
  void DeleteTrafficMirrorTargetAsync(const DeleteTrafficMirrorTargetRequestT& request,
                                      const DeleteTrafficMirrorTargetResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTrafficMirrorTarget, request, handler, context);
  }

  /**
   * <p>Deletes the specified transit gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGateway">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayRequestT = Model::DeleteTransitGatewayRequest>
  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 <typename DeleteTransitGatewayRequestT = Model::DeleteTransitGatewayRequest>
  void DeleteTransitGatewayAsync(const DeleteTransitGatewayRequestT& request, const DeleteTransitGatewayResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGateway, request, handler, context);
  }

  /**
   * <p>Deletes the specified Connect attachment. You must first delete any Connect
   * peers for the attachment.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayConnect">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayConnectRequestT = Model::DeleteTransitGatewayConnectRequest>
  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 <typename DeleteTransitGatewayConnectRequestT = Model::DeleteTransitGatewayConnectRequest>
  void DeleteTransitGatewayConnectAsync(const DeleteTransitGatewayConnectRequestT& request,
                                        const DeleteTransitGatewayConnectResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayConnect, request, handler, context);
  }

  /**
   * <p>Deletes the specified Connect peer.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayConnectPeer">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayConnectPeerRequestT = Model::DeleteTransitGatewayConnectPeerRequest>
  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 <typename DeleteTransitGatewayConnectPeerRequestT = Model::DeleteTransitGatewayConnectPeerRequest>
  void DeleteTransitGatewayConnectPeerAsync(const DeleteTransitGatewayConnectPeerRequestT& request,
                                            const DeleteTransitGatewayConnectPeerResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayConnectPeer, request, handler, context);
  }

  /**
   * <p>Deletes a transit gateway metering policy.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayMeteringPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteTransitGatewayMeteringPolicyOutcome DeleteTransitGatewayMeteringPolicy(
      const Model::DeleteTransitGatewayMeteringPolicyRequest& request) const;

  /**
   * A Callable wrapper for DeleteTransitGatewayMeteringPolicy that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DeleteTransitGatewayMeteringPolicyRequestT = Model::DeleteTransitGatewayMeteringPolicyRequest>
  Model::DeleteTransitGatewayMeteringPolicyOutcomeCallable DeleteTransitGatewayMeteringPolicyCallable(
      const DeleteTransitGatewayMeteringPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayMeteringPolicy, request);
  }

  /**
   * An Async wrapper for DeleteTransitGatewayMeteringPolicy that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DeleteTransitGatewayMeteringPolicyRequestT = Model::DeleteTransitGatewayMeteringPolicyRequest>
  void DeleteTransitGatewayMeteringPolicyAsync(const DeleteTransitGatewayMeteringPolicyRequestT& request,
                                               const DeleteTransitGatewayMeteringPolicyResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayMeteringPolicy, request, handler, context);
  }

  /**
   * <p>Deletes an entry from a transit gateway metering policy.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayMeteringPolicyEntry">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteTransitGatewayMeteringPolicyEntryOutcome DeleteTransitGatewayMeteringPolicyEntry(
      const Model::DeleteTransitGatewayMeteringPolicyEntryRequest& request) const;

  /**
   * A Callable wrapper for DeleteTransitGatewayMeteringPolicyEntry that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DeleteTransitGatewayMeteringPolicyEntryRequestT = Model::DeleteTransitGatewayMeteringPolicyEntryRequest>
  Model::DeleteTransitGatewayMeteringPolicyEntryOutcomeCallable DeleteTransitGatewayMeteringPolicyEntryCallable(
      const DeleteTransitGatewayMeteringPolicyEntryRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayMeteringPolicyEntry, request);
  }

  /**
   * An Async wrapper for DeleteTransitGatewayMeteringPolicyEntry that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DeleteTransitGatewayMeteringPolicyEntryRequestT = Model::DeleteTransitGatewayMeteringPolicyEntryRequest>
  void DeleteTransitGatewayMeteringPolicyEntryAsync(const DeleteTransitGatewayMeteringPolicyEntryRequestT& request,
                                                    const DeleteTransitGatewayMeteringPolicyEntryResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayMeteringPolicyEntry, request, handler, context);
  }

  /**
   * <p>Deletes the specified transit gateway multicast domain.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayMulticastDomain">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayMulticastDomainRequestT = Model::DeleteTransitGatewayMulticastDomainRequest>
  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 <typename DeleteTransitGatewayMulticastDomainRequestT = Model::DeleteTransitGatewayMulticastDomainRequest>
  void DeleteTransitGatewayMulticastDomainAsync(const DeleteTransitGatewayMulticastDomainRequestT& request,
                                                const DeleteTransitGatewayMulticastDomainResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayMulticastDomain, request, handler, context);
  }

  /**
   * <p>Deletes a transit gateway peering attachment.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPeeringAttachment">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayPeeringAttachmentRequestT = Model::DeleteTransitGatewayPeeringAttachmentRequest>
  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 <typename DeleteTransitGatewayPeeringAttachmentRequestT = Model::DeleteTransitGatewayPeeringAttachmentRequest>
  void DeleteTransitGatewayPeeringAttachmentAsync(const DeleteTransitGatewayPeeringAttachmentRequestT& request,
                                                  const DeleteTransitGatewayPeeringAttachmentResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayPeeringAttachment, request, handler, context);
  }

  /**
   * <p>Deletes the specified transit gateway policy table.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPolicyTable">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayPolicyTableRequestT = Model::DeleteTransitGatewayPolicyTableRequest>
  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 <typename DeleteTransitGatewayPolicyTableRequestT = Model::DeleteTransitGatewayPolicyTableRequest>
  void DeleteTransitGatewayPolicyTableAsync(const DeleteTransitGatewayPolicyTableRequestT& request,
                                            const DeleteTransitGatewayPolicyTableResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayPolicyTable, request, handler, context);
  }

  /**
   * <p>Deletes a reference (route) to a prefix list in a specified transit gateway
   * route table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPrefixListReference">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayPrefixListReferenceRequestT = Model::DeleteTransitGatewayPrefixListReferenceRequest>
  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 <typename DeleteTransitGatewayPrefixListReferenceRequestT = Model::DeleteTransitGatewayPrefixListReferenceRequest>
  void DeleteTransitGatewayPrefixListReferenceAsync(const DeleteTransitGatewayPrefixListReferenceRequestT& request,
                                                    const DeleteTransitGatewayPrefixListReferenceResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayPrefixListReference, request, handler, context);
  }

  /**
   * <p>Deletes the specified route from the specified transit gateway route
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRoute">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayRouteRequestT = Model::DeleteTransitGatewayRouteRequest>
  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 <typename DeleteTransitGatewayRouteRequestT = Model::DeleteTransitGatewayRouteRequest>
  void DeleteTransitGatewayRouteAsync(const DeleteTransitGatewayRouteRequestT& request,
                                      const DeleteTransitGatewayRouteResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayRoute, request, handler, context);
  }

  /**
   * <p>Deletes the specified transit gateway route table. If there are any route
   * tables associated with the transit gateway route table, you must first run
   * <a>DisassociateRouteTable</a> before you can delete the transit gateway route
   * table. This removes any route tables associated with the transit gateway route
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayRouteTableRequestT = Model::DeleteTransitGatewayRouteTableRequest>
  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 <typename DeleteTransitGatewayRouteTableRequestT = Model::DeleteTransitGatewayRouteTableRequest>
  void DeleteTransitGatewayRouteTableAsync(const DeleteTransitGatewayRouteTableRequestT& request,
                                           const DeleteTransitGatewayRouteTableResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayRouteTable, request, handler, context);
  }

  /**
   * <p>Advertises to the transit gateway that a transit gateway route table is
   * deleted.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRouteTableAnnouncement">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayRouteTableAnnouncementRequestT = Model::DeleteTransitGatewayRouteTableAnnouncementRequest>
  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 <typename DeleteTransitGatewayRouteTableAnnouncementRequestT = Model::DeleteTransitGatewayRouteTableAnnouncementRequest>
  void DeleteTransitGatewayRouteTableAnnouncementAsync(
      const DeleteTransitGatewayRouteTableAnnouncementRequestT& request,
      const DeleteTransitGatewayRouteTableAnnouncementResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayRouteTableAnnouncement, request, handler, context);
  }

  /**
   * <p>Deletes the specified VPC attachment.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayVpcAttachment">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteTransitGatewayVpcAttachmentRequestT = Model::DeleteTransitGatewayVpcAttachmentRequest>
  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 <typename DeleteTransitGatewayVpcAttachmentRequestT = Model::DeleteTransitGatewayVpcAttachmentRequest>
  void DeleteTransitGatewayVpcAttachmentAsync(const DeleteTransitGatewayVpcAttachmentRequestT& request,
                                              const DeleteTransitGatewayVpcAttachmentResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayVpcAttachment, request, handler, context);
  }

  /**
   * <p>Delete an Amazon Web Services Verified Access endpoint.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVerifiedAccessEndpointRequestT = Model::DeleteVerifiedAccessEndpointRequest>
  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 <typename DeleteVerifiedAccessEndpointRequestT = Model::DeleteVerifiedAccessEndpointRequest>
  void DeleteVerifiedAccessEndpointAsync(const DeleteVerifiedAccessEndpointRequestT& request,
                                         const DeleteVerifiedAccessEndpointResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVerifiedAccessEndpoint, request, handler, context);
  }

  /**
   * <p>Delete an Amazon Web Services Verified Access group.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessGroup">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVerifiedAccessGroupRequestT = Model::DeleteVerifiedAccessGroupRequest>
  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 <typename DeleteVerifiedAccessGroupRequestT = Model::DeleteVerifiedAccessGroupRequest>
  void DeleteVerifiedAccessGroupAsync(const DeleteVerifiedAccessGroupRequestT& request,
                                      const DeleteVerifiedAccessGroupResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVerifiedAccessGroup, request, handler, context);
  }

  /**
   * <p>Delete an Amazon Web Services Verified Access instance.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessInstance">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVerifiedAccessInstanceRequestT = Model::DeleteVerifiedAccessInstanceRequest>
  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 <typename DeleteVerifiedAccessInstanceRequestT = Model::DeleteVerifiedAccessInstanceRequest>
  void DeleteVerifiedAccessInstanceAsync(const DeleteVerifiedAccessInstanceRequestT& request,
                                         const DeleteVerifiedAccessInstanceResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVerifiedAccessInstance, request, handler, context);
  }

  /**
   * <p>Delete an Amazon Web Services Verified Access trust provider.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessTrustProvider">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVerifiedAccessTrustProviderRequestT = Model::DeleteVerifiedAccessTrustProviderRequest>
  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 <typename DeleteVerifiedAccessTrustProviderRequestT = Model::DeleteVerifiedAccessTrustProviderRequest>
  void DeleteVerifiedAccessTrustProviderAsync(const DeleteVerifiedAccessTrustProviderRequestT& request,
                                              const DeleteVerifiedAccessTrustProviderResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVerifiedAccessTrustProvider, request, handler, context);
  }

  /**
   * <p>Deletes the specified EBS volume. The volume must be in the
   * <code>available</code> state (not attached to an instance).</p> <p>The volume
   * can remain in the <code>deleting</code> state for several minutes.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-deleting-volume.html">Delete
   * an Amazon EBS volume</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVolume">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVolumeRequestT = Model::DeleteVolumeRequest>
  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 <typename DeleteVolumeRequestT = Model::DeleteVolumeRequest>
  void DeleteVolumeAsync(const DeleteVolumeRequestT& request, const DeleteVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVolume, request, handler, context);
  }

  /**
   * <p>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. When
   * you delete the VPC, it deletes the default security group, network ACL, and
   * route table for the VPC.</p> <p>If you created a flow log for the VPC that you
   * are deleting, note that flow logs for deleted VPCs are eventually automatically
   * removed.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpc">AWS API
   * Reference</a></p>
   */
  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 <typename DeleteVpcRequestT = Model::DeleteVpcRequest>
  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 <typename DeleteVpcRequestT = Model::DeleteVpcRequest>
  void DeleteVpcAsync(const DeleteVpcRequestT& request, const DeleteVpcResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpc, request, handler, context);
  }

  /**
   * <p>Delete a VPC Block Public Access (BPA) exclusion. A VPC BPA exclusion is a
   * mode that can be applied to a single VPC or subnet that exempts it from the
   * account’s BPA mode and will allow bidirectional or egress-only access. You can
   * create BPA exclusions for VPCs and subnets even when BPA is not enabled on the
   * account to ensure that there is no traffic disruption to the exclusions when VPC
   * BPA is turned on. To learn more about VPC BPA, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/security-vpc-bpa.html">Block
   * public access to VPCs and subnets</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcBlockPublicAccessExclusion">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteVpcBlockPublicAccessExclusionOutcome DeleteVpcBlockPublicAccessExclusion(
      const Model::DeleteVpcBlockPublicAccessExclusionRequest& request) const;

  /**
   * A Callable wrapper for DeleteVpcBlockPublicAccessExclusion that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DeleteVpcBlockPublicAccessExclusionRequestT = Model::DeleteVpcBlockPublicAccessExclusionRequest>
  Model::DeleteVpcBlockPublicAccessExclusionOutcomeCallable DeleteVpcBlockPublicAccessExclusionCallable(
      const DeleteVpcBlockPublicAccessExclusionRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpcBlockPublicAccessExclusion, request);
  }

  /**
   * An Async wrapper for DeleteVpcBlockPublicAccessExclusion that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DeleteVpcBlockPublicAccessExclusionRequestT = Model::DeleteVpcBlockPublicAccessExclusionRequest>
  void DeleteVpcBlockPublicAccessExclusionAsync(const DeleteVpcBlockPublicAccessExclusionRequestT& request,
                                                const DeleteVpcBlockPublicAccessExclusionResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpcBlockPublicAccessExclusion, request, handler, context);
  }

  /**
   * <p>Deletes a VPC Encryption Control configuration. This removes the encryption
   * policy enforcement from the specified VPC.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html">Enforce
   * VPC encryption in transit</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEncryptionControl">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteVpcEncryptionControlOutcome DeleteVpcEncryptionControl(
      const Model::DeleteVpcEncryptionControlRequest& request) const;

  /**
   * A Callable wrapper for DeleteVpcEncryptionControl that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DeleteVpcEncryptionControlRequestT = Model::DeleteVpcEncryptionControlRequest>
  Model::DeleteVpcEncryptionControlOutcomeCallable DeleteVpcEncryptionControlCallable(
      const DeleteVpcEncryptionControlRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpcEncryptionControl, request);
  }

  /**
   * An Async wrapper for DeleteVpcEncryptionControl that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteVpcEncryptionControlRequestT = Model::DeleteVpcEncryptionControlRequest>
  void DeleteVpcEncryptionControlAsync(const DeleteVpcEncryptionControlRequestT& request,
                                       const DeleteVpcEncryptionControlResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpcEncryptionControl, request, handler, context);
  }

  /**
   * <p>Deletes the specified VPC endpoint connection notifications.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpointConnectionNotifications">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVpcEndpointConnectionNotificationsRequestT = Model::DeleteVpcEndpointConnectionNotificationsRequest>
  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 <typename DeleteVpcEndpointConnectionNotificationsRequestT = Model::DeleteVpcEndpointConnectionNotificationsRequest>
  void DeleteVpcEndpointConnectionNotificationsAsync(
      const DeleteVpcEndpointConnectionNotificationsRequestT& request,
      const DeleteVpcEndpointConnectionNotificationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpcEndpointConnectionNotifications, request, handler, context);
  }

  /**
   * <p>Deletes the specified VPC endpoint service configurations. Before you can
   * delete an endpoint service configuration, you must reject any
   * <code>Available</code> or <code>PendingAcceptance</code> interface endpoint
   * connections that are attached to the service.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpointServiceConfigurations">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVpcEndpointServiceConfigurationsRequestT = Model::DeleteVpcEndpointServiceConfigurationsRequest>
  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 <typename DeleteVpcEndpointServiceConfigurationsRequestT = Model::DeleteVpcEndpointServiceConfigurationsRequest>
  void DeleteVpcEndpointServiceConfigurationsAsync(const DeleteVpcEndpointServiceConfigurationsRequestT& request,
                                                   const DeleteVpcEndpointServiceConfigurationsResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpcEndpointServiceConfigurations, request, handler, context);
  }

  /**
   * <p>Deletes the specified VPC endpoints.</p> <p>When you delete a gateway
   * endpoint, we delete the endpoint routes in the route tables for the
   * endpoint.</p> <p>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.</p> <p>When
   * you delete an interface endpoint, we delete its endpoint network
   * interfaces.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpoints">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVpcEndpointsRequestT = Model::DeleteVpcEndpointsRequest>
  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 <typename DeleteVpcEndpointsRequestT = Model::DeleteVpcEndpointsRequest>
  void DeleteVpcEndpointsAsync(const DeleteVpcEndpointsRequestT& request, const DeleteVpcEndpointsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpcEndpoints, request, handler, context);
  }

  /**
   * <p>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 <code>active</code> state. The owner of the requester VPC can delete a VPC
   * peering connection in the <code>pending-acceptance</code> state. You cannot
   * delete a VPC peering connection that's in the <code>failed</code> or
   * <code>rejected</code> state.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcPeeringConnection">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVpcPeeringConnectionRequestT = Model::DeleteVpcPeeringConnectionRequest>
  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 <typename DeleteVpcPeeringConnectionRequestT = Model::DeleteVpcPeeringConnectionRequest>
  void DeleteVpcPeeringConnectionAsync(const DeleteVpcPeeringConnectionRequestT& request,
                                       const DeleteVpcPeeringConnectionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpcPeeringConnection, request, handler, context);
  }

  /**
   * <p>Deletes the specified VPN concentrator.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConcentrator">AWS
   * API Reference</a></p>
   */
  virtual Model::DeleteVpnConcentratorOutcome DeleteVpnConcentrator(const Model::DeleteVpnConcentratorRequest& request) const;

  /**
   * A Callable wrapper for DeleteVpnConcentrator that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeleteVpnConcentratorRequestT = Model::DeleteVpnConcentratorRequest>
  Model::DeleteVpnConcentratorOutcomeCallable DeleteVpnConcentratorCallable(const DeleteVpnConcentratorRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpnConcentrator, request);
  }

  /**
   * An Async wrapper for DeleteVpnConcentrator that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeleteVpnConcentratorRequestT = Model::DeleteVpnConcentratorRequest>
  void DeleteVpnConcentratorAsync(const DeleteVpnConcentratorRequestT& request, const DeleteVpnConcentratorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpnConcentrator, request, handler, context);
  }

  /**
   * <p>Deletes the specified VPN connection.</p> <p>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.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnection">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVpnConnectionRequestT = Model::DeleteVpnConnectionRequest>
  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 <typename DeleteVpnConnectionRequestT = Model::DeleteVpnConnectionRequest>
  void DeleteVpnConnectionAsync(const DeleteVpnConnectionRequestT& request, const DeleteVpnConnectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpnConnection, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnectionRoute">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVpnConnectionRouteRequestT = Model::DeleteVpnConnectionRouteRequest>
  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 <typename DeleteVpnConnectionRouteRequestT = Model::DeleteVpnConnectionRouteRequest>
  void DeleteVpnConnectionRouteAsync(const DeleteVpnConnectionRouteRequestT& request,
                                     const DeleteVpnConnectionRouteResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpnConnectionRoute, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnGateway">AWS
   * API Reference</a></p>
   */
  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 <typename DeleteVpnGatewayRequestT = Model::DeleteVpnGatewayRequest>
  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 <typename DeleteVpnGatewayRequestT = Model::DeleteVpnGatewayRequest>
  void DeleteVpnGatewayAsync(const DeleteVpnGatewayRequestT& request, const DeleteVpnGatewayResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteVpnGateway, request, handler, context);
  }

  /**
   * <p>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.</p> <p>Before you can release an address
   * range, you must stop advertising it and you must not have any IP addresses
   * allocated from its address range.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionByoipCidr">AWS
   * API Reference</a></p>
   */
  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 <typename DeprovisionByoipCidrRequestT = Model::DeprovisionByoipCidrRequest>
  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 <typename DeprovisionByoipCidrRequestT = Model::DeprovisionByoipCidrRequest>
  void DeprovisionByoipCidrAsync(const DeprovisionByoipCidrRequestT& request, const DeprovisionByoipCidrResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeprovisionByoipCidr, request, handler, context);
  }

  /**
   * <p>Deprovisions your Autonomous System Number (ASN) from your Amazon Web
   * Services account. This action can only be called after any BYOIP CIDR
   * associations are removed from your Amazon Web Services account with <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIpamByoasn.html">DisassociateIpamByoasn</a>.
   * For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoasn.html">Tutorial:
   * Bring your ASN to IPAM</a> in the <i>Amazon VPC IPAM guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionIpamByoasn">AWS
   * API Reference</a></p>
   */
  virtual Model::DeprovisionIpamByoasnOutcome DeprovisionIpamByoasn(const Model::DeprovisionIpamByoasnRequest& request) const;

  /**
   * A Callable wrapper for DeprovisionIpamByoasn that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DeprovisionIpamByoasnRequestT = Model::DeprovisionIpamByoasnRequest>
  Model::DeprovisionIpamByoasnOutcomeCallable DeprovisionIpamByoasnCallable(const DeprovisionIpamByoasnRequestT& request) const {
    return SubmitCallable(&EC2Client::DeprovisionIpamByoasn, request);
  }

  /**
   * An Async wrapper for DeprovisionIpamByoasn that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DeprovisionIpamByoasnRequestT = Model::DeprovisionIpamByoasnRequest>
  void DeprovisionIpamByoasnAsync(const DeprovisionIpamByoasnRequestT& request, const DeprovisionIpamByoasnResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeprovisionIpamByoasn, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/depro-pool-cidr-ipam.html">Deprovision
   * pool CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionIpamPoolCidr">AWS
   * API Reference</a></p>
   */
  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 <typename DeprovisionIpamPoolCidrRequestT = Model::DeprovisionIpamPoolCidrRequest>
  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 <typename DeprovisionIpamPoolCidrRequestT = Model::DeprovisionIpamPoolCidrRequest>
  void DeprovisionIpamPoolCidrAsync(const DeprovisionIpamPoolCidrRequestT& request,
                                    const DeprovisionIpamPoolCidrResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeprovisionIpamPoolCidr, request, handler, context);
  }

  /**
   * <p>Deprovision a CIDR from a public IPv4 pool.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionPublicIpv4PoolCidr">AWS
   * API Reference</a></p>
   */
  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 <typename DeprovisionPublicIpv4PoolCidrRequestT = Model::DeprovisionPublicIpv4PoolCidrRequest>
  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 <typename DeprovisionPublicIpv4PoolCidrRequestT = Model::DeprovisionPublicIpv4PoolCidrRequest>
  void DeprovisionPublicIpv4PoolCidrAsync(const DeprovisionPublicIpv4PoolCidrRequestT& request,
                                          const DeprovisionPublicIpv4PoolCidrResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeprovisionPublicIpv4PoolCidr, request, handler, context);
  }

  /**
   * <p>Deregisters the specified AMI. A deregistered AMI can't be used to launch new
   * instances.</p> <p>If a deregistered EBS-backed AMI matches a Recycle Bin
   * retention rule, it moves to the Recycle Bin for the specified retention period.
   * It can be restored before its retention period expires, after which it is
   * permanently deleted. If the deregistered AMI doesn't match a retention rule, it
   * is permanently deleted immediately. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin.html">Recover
   * deleted Amazon EBS snapshots and EBS-backed AMIs with Recycle Bin</a> in the
   * <i>Amazon EBS User Guide</i>.</p> <p>When deregistering an EBS-backed AMI, you
   * can optionally delete its associated snapshots at the same time. However, if a
   * snapshot is associated with multiple AMIs, it won't be deleted even if specified
   * for deletion, although the AMI will still be deregistered.</p> <p>Deregistering
   * an AMI does not delete the following:</p> <ul> <li> <p>Instances already
   * launched from the AMI. You'll continue to incur usage costs for the instances
   * until you terminate them.</p> </li> <li> <p>For EBS-backed AMIs: Snapshots that
   * are associated with multiple AMIs. You'll continue to incur snapshot storage
   * costs.</p> </li> <li> <p>For instance store-backed AMIs: The files uploaded to
   * Amazon S3 during AMI creation. You'll continue to incur S3 storage costs.</p>
   * </li> </ul> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/deregister-ami.html">Deregister
   * an Amazon EC2 AMI</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterImage">AWS
   * API Reference</a></p>
   */
  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 <typename DeregisterImageRequestT = Model::DeregisterImageRequest>
  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 <typename DeregisterImageRequestT = Model::DeregisterImageRequest>
  void DeregisterImageAsync(const DeregisterImageRequestT& request, const DeregisterImageResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeregisterImage, request, handler, context);
  }

  /**
   * <p>Deregisters tag keys to prevent tags that have the specified tag keys from
   * being included in scheduled event notifications for resources in the
   * Region.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterInstanceEventNotificationAttributes">AWS
   * API Reference</a></p>
   */
  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 <typename DeregisterInstanceEventNotificationAttributesRequestT = Model::DeregisterInstanceEventNotificationAttributesRequest>
  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 <typename DeregisterInstanceEventNotificationAttributesRequestT = Model::DeregisterInstanceEventNotificationAttributesRequest>
  void DeregisterInstanceEventNotificationAttributesAsync(
      const DeregisterInstanceEventNotificationAttributesRequestT& request,
      const DeregisterInstanceEventNotificationAttributesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeregisterInstanceEventNotificationAttributes, request, handler, context);
  }

  /**
   * <p>Deregisters the specified members (network interfaces) from the transit
   * gateway multicast group.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterTransitGatewayMulticastGroupMembers">AWS
   * API Reference</a></p>
   */
  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 <typename DeregisterTransitGatewayMulticastGroupMembersRequestT = Model::DeregisterTransitGatewayMulticastGroupMembersRequest>
  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 <typename DeregisterTransitGatewayMulticastGroupMembersRequestT = Model::DeregisterTransitGatewayMulticastGroupMembersRequest>
  void DeregisterTransitGatewayMulticastGroupMembersAsync(
      const DeregisterTransitGatewayMulticastGroupMembersResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DeregisterTransitGatewayMulticastGroupMembersRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DeregisterTransitGatewayMulticastGroupMembers, request, handler, context);
  }

  /**
   * <p>Deregisters the specified sources (network interfaces) from the transit
   * gateway multicast group.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterTransitGatewayMulticastGroupSources">AWS
   * API Reference</a></p>
   */
  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 <typename DeregisterTransitGatewayMulticastGroupSourcesRequestT = Model::DeregisterTransitGatewayMulticastGroupSourcesRequest>
  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 <typename DeregisterTransitGatewayMulticastGroupSourcesRequestT = Model::DeregisterTransitGatewayMulticastGroupSourcesRequest>
  void DeregisterTransitGatewayMulticastGroupSourcesAsync(
      const DeregisterTransitGatewayMulticastGroupSourcesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DeregisterTransitGatewayMulticastGroupSourcesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DeregisterTransitGatewayMulticastGroupSources, request, handler, context);
  }

  /**
   * <p>Describes attributes of your Amazon Web Services account. The following are
   * the supported account attributes:</p> <ul> <li> <p> <code>default-vpc</code>:
   * The ID of the default VPC for your account, or <code>none</code>.</p> </li> <li>
   * <p> <code>max-instances</code>: 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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-on-demand-instances.html#ec2-on-demand-instances-limits">On-Demand
   * Instance Limits</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
   * </li> <li> <p> <code>max-elastic-ips</code>: The maximum number of Elastic IP
   * addresses that you can allocate.</p> </li> <li> <p>
   * <code>supported-platforms</code>: This attribute is deprecated.</p> </li> <li>
   * <p> <code>vpc-max-elastic-ips</code>: The maximum number of Elastic IP addresses
   * that you can allocate.</p> </li> <li> <p>
   * <code>vpc-max-security-groups-per-interface</code>: The maximum number of
   * security groups that you can assign to a network interface.</p> </li> </ul>
   *  <p>The order of the elements in the response, including those within
   * nested structures, might vary. Applications should not assume the elements
   * appear in a particular order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAccountAttributes">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeAccountAttributesRequestT = Model::DescribeAccountAttributesRequest>
  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 <typename DescribeAccountAttributesRequestT = Model::DescribeAccountAttributesRequest>
  void DescribeAccountAttributesAsync(const DescribeAccountAttributesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeAccountAttributesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeAccountAttributes, request, handler, context);
  }

  /**
   * <p>Describes an Elastic IP address transfer. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro">Transfer
   * Elastic IP addresses</a> in the <i>Amazon VPC User Guide</i>.</p> <p>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 14 days after the transfers have
   * been accepted.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddressTransfers">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeAddressTransfersRequestT = Model::DescribeAddressTransfersRequest>
  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 <typename DescribeAddressTransfersRequestT = Model::DescribeAddressTransfersRequest>
  void DescribeAddressTransfersAsync(const DescribeAddressTransfersResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeAddressTransfersRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeAddressTransfers, request, handler, context);
  }

  /**
   * <p>Describes the specified Elastic IP addresses or all of your Elastic IP
   * addresses.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddresses">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeAddressesRequestT = Model::DescribeAddressesRequest>
  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 <typename DescribeAddressesRequestT = Model::DescribeAddressesRequest>
  void DescribeAddressesAsync(const DescribeAddressesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeAddressesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeAddresses, request, handler, context);
  }

  /**
   * <p>Describes the attributes of the specified Elastic IP addresses. For
   * requirements, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html#Using_Elastic_Addressing_Reverse_DNS">Using
   * reverse DNS for email applications</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddressesAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeAddressesAttributeRequestT = Model::DescribeAddressesAttributeRequest>
  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 <typename DescribeAddressesAttributeRequestT = Model::DescribeAddressesAttributeRequest>
  void DescribeAddressesAttributeAsync(const DescribeAddressesAttributeResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeAddressesAttributeRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeAddressesAttribute, request, handler, context);
  }

  /**
   * <p>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).</p>
   * <p>This request only returns information about resource types that support
   * longer IDs.</p> <p>The following resource types support longer IDs:
   * <code>bundle</code> | <code>conversion-task</code> |
   * <code>customer-gateway</code> | <code>dhcp-options</code> |
   * <code>elastic-ip-allocation</code> | <code>elastic-ip-association</code> |
   * <code>export-task</code> | <code>flow-log</code> | <code>image</code> |
   * <code>import-task</code> | <code>instance</code> | <code>internet-gateway</code>
   * | <code>network-acl</code> | <code>network-acl-association</code> |
   * <code>network-interface</code> | <code>network-interface-attachment</code> |
   * <code>prefix-list</code> | <code>reservation</code> | <code>route-table</code> |
   * <code>route-table-association</code> | <code>security-group</code> |
   * <code>snapshot</code> | <code>subnet</code> |
   * <code>subnet-cidr-block-association</code> | <code>volume</code> |
   * <code>vpc</code> | <code>vpc-cidr-block-association</code> |
   * <code>vpc-endpoint</code> | <code>vpc-peering-connection</code> |
   * <code>vpn-connection</code> | <code>vpn-gateway</code>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAggregateIdFormat">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeAggregateIdFormatRequestT = Model::DescribeAggregateIdFormatRequest>
  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 <typename DescribeAggregateIdFormatRequestT = Model::DescribeAggregateIdFormatRequest>
  void DescribeAggregateIdFormatAsync(const DescribeAggregateIdFormatResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeAggregateIdFormatRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeAggregateIdFormat, request, handler, context);
  }

  /**
   * <p>Describes the Availability Zones, Local Zones, and Wavelength Zones that are
   * available to you.</p> <p>For more information about Availability Zones, Local
   * Zones, and Wavelength Zones, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html">Regions
   * and zones</a> in the <i>Amazon EC2 User Guide</i>.</p>  <p>The order of
   * the elements in the response, including those within nested structures, might
   * vary. Applications should not assume the elements appear in a particular
   * order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAvailabilityZones">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeAvailabilityZonesRequestT = Model::DescribeAvailabilityZonesRequest>
  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 <typename DescribeAvailabilityZonesRequestT = Model::DescribeAvailabilityZonesRequest>
  void DescribeAvailabilityZonesAsync(const DescribeAvailabilityZonesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeAvailabilityZonesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeAvailabilityZones, request, handler, context);
  }

  /**
   * <p>Describes the current Infrastructure Performance metric
   * subscriptions.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAwsNetworkPerformanceMetricSubscriptions">AWS
   * API Reference</a></p>
   */
  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 <
      typename DescribeAwsNetworkPerformanceMetricSubscriptionsRequestT = Model::DescribeAwsNetworkPerformanceMetricSubscriptionsRequest>
  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 <
      typename DescribeAwsNetworkPerformanceMetricSubscriptionsRequestT = Model::DescribeAwsNetworkPerformanceMetricSubscriptionsRequest>
  void DescribeAwsNetworkPerformanceMetricSubscriptionsAsync(
      const DescribeAwsNetworkPerformanceMetricSubscriptionsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DescribeAwsNetworkPerformanceMetricSubscriptionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeAwsNetworkPerformanceMetricSubscriptions, request, handler, context);
  }

  /**
   * <p>Describes the specified bundle tasks or all of your bundle tasks.</p>
   * <p>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
   * <code>RegisterImage</code> with the Amazon S3 bucket name and image manifest
   * name you provided to the bundle task.</p>   <p>The order of the
   * elements in the response, including those within nested structures, might vary.
   * Applications should not assume the elements appear in a particular order.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeBundleTasks">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeBundleTasksRequestT = Model::DescribeBundleTasksRequest>
  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 <typename DescribeBundleTasksRequestT = Model::DescribeBundleTasksRequest>
  void DescribeBundleTasksAsync(const DescribeBundleTasksResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeBundleTasksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeBundleTasks, request, handler, context);
  }

  /**
   * <p>Describes the IP address ranges that were provisioned for use with Amazon Web
   * Services resources through through bring your own IP addresses
   * (BYOIP).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeByoipCidrs">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeByoipCidrsRequestT = Model::DescribeByoipCidrsRequest>
  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 <typename DescribeByoipCidrsRequestT = Model::DescribeByoipCidrsRequest>
  void DescribeByoipCidrsAsync(const DescribeByoipCidrsRequestT& request, const DescribeByoipCidrsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeByoipCidrs, request, handler, context);
  }

  /**
   * <p>Describes the events for the specified Capacity Block extension during the
   * specified time.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityBlockExtensionHistory">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeCapacityBlockExtensionHistoryOutcome DescribeCapacityBlockExtensionHistory(
      const Model::DescribeCapacityBlockExtensionHistoryRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeCapacityBlockExtensionHistory that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeCapacityBlockExtensionHistoryRequestT = Model::DescribeCapacityBlockExtensionHistoryRequest>
  Model::DescribeCapacityBlockExtensionHistoryOutcomeCallable DescribeCapacityBlockExtensionHistoryCallable(
      const DescribeCapacityBlockExtensionHistoryRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlockExtensionHistory, request);
  }

  /**
   * An Async wrapper for DescribeCapacityBlockExtensionHistory that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeCapacityBlockExtensionHistoryRequestT = Model::DescribeCapacityBlockExtensionHistoryRequest>
  void DescribeCapacityBlockExtensionHistoryAsync(const DescribeCapacityBlockExtensionHistoryResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const DescribeCapacityBlockExtensionHistoryRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCapacityBlockExtensionHistory, request, handler, context);
  }

  /**
   * <p>Describes Capacity Block extension offerings available for purchase in the
   * Amazon Web Services Region that you're currently using.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityBlockExtensionOfferings">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeCapacityBlockExtensionOfferingsOutcome DescribeCapacityBlockExtensionOfferings(
      const Model::DescribeCapacityBlockExtensionOfferingsRequest& request) const;

  /**
   * A Callable wrapper for DescribeCapacityBlockExtensionOfferings that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeCapacityBlockExtensionOfferingsRequestT = Model::DescribeCapacityBlockExtensionOfferingsRequest>
  Model::DescribeCapacityBlockExtensionOfferingsOutcomeCallable DescribeCapacityBlockExtensionOfferingsCallable(
      const DescribeCapacityBlockExtensionOfferingsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlockExtensionOfferings, request);
  }

  /**
   * An Async wrapper for DescribeCapacityBlockExtensionOfferings that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeCapacityBlockExtensionOfferingsRequestT = Model::DescribeCapacityBlockExtensionOfferingsRequest>
  void DescribeCapacityBlockExtensionOfferingsAsync(const DescribeCapacityBlockExtensionOfferingsRequestT& request,
                                                    const DescribeCapacityBlockExtensionOfferingsResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeCapacityBlockExtensionOfferings, request, handler, context);
  }

  /**
   * <p>Describes Capacity Block offerings available for purchase in the Amazon Web
   * Services Region that you're currently using. With Capacity Blocks, you can
   * purchase a specific GPU instance type or EC2 UltraServer for a period of
   * time.</p> <p>To search for an available Capacity Block offering, you specify a
   * reservation duration and instance count.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityBlockOfferings">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeCapacityBlockOfferingsOutcome DescribeCapacityBlockOfferings(
      const Model::DescribeCapacityBlockOfferingsRequest& request) const;

  /**
   * A Callable wrapper for DescribeCapacityBlockOfferings that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeCapacityBlockOfferingsRequestT = Model::DescribeCapacityBlockOfferingsRequest>
  Model::DescribeCapacityBlockOfferingsOutcomeCallable DescribeCapacityBlockOfferingsCallable(
      const DescribeCapacityBlockOfferingsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlockOfferings, request);
  }

  /**
   * An Async wrapper for DescribeCapacityBlockOfferings that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DescribeCapacityBlockOfferingsRequestT = Model::DescribeCapacityBlockOfferingsRequest>
  void DescribeCapacityBlockOfferingsAsync(const DescribeCapacityBlockOfferingsRequestT& request,
                                           const DescribeCapacityBlockOfferingsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeCapacityBlockOfferings, request, handler, context);
  }

  /**
   * <p>Describes the availability of capacity for the specified Capacity blocks, or
   * all of your Capacity Blocks.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityBlockStatus">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeCapacityBlockStatusOutcome DescribeCapacityBlockStatus(
      const Model::DescribeCapacityBlockStatusRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeCapacityBlockStatus that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeCapacityBlockStatusRequestT = Model::DescribeCapacityBlockStatusRequest>
  Model::DescribeCapacityBlockStatusOutcomeCallable DescribeCapacityBlockStatusCallable(
      const DescribeCapacityBlockStatusRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlockStatus, request);
  }

  /**
   * An Async wrapper for DescribeCapacityBlockStatus that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeCapacityBlockStatusRequestT = Model::DescribeCapacityBlockStatusRequest>
  void DescribeCapacityBlockStatusAsync(const DescribeCapacityBlockStatusResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeCapacityBlockStatusRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCapacityBlockStatus, request, handler, context);
  }

  /**
   * <p>Describes details about Capacity Blocks in the Amazon Web Services Region
   * that you're currently using.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityBlocks">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeCapacityBlocksOutcome DescribeCapacityBlocks(const Model::DescribeCapacityBlocksRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeCapacityBlocks that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeCapacityBlocksRequestT = Model::DescribeCapacityBlocksRequest>
  Model::DescribeCapacityBlocksOutcomeCallable DescribeCapacityBlocksCallable(const DescribeCapacityBlocksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlocks, request);
  }

  /**
   * An Async wrapper for DescribeCapacityBlocks that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeCapacityBlocksRequestT = Model::DescribeCapacityBlocksRequest>
  void DescribeCapacityBlocksAsync(const DescribeCapacityBlocksResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeCapacityBlocksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCapacityBlocks, request, handler, context);
  }

  /**
   * <p> Describes one or more Capacity Manager data export configurations. Returns
   * information about export settings, delivery status, and recent export activity.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityManagerDataExports">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeCapacityManagerDataExportsOutcome DescribeCapacityManagerDataExports(
      const Model::DescribeCapacityManagerDataExportsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeCapacityManagerDataExports that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DescribeCapacityManagerDataExportsRequestT = Model::DescribeCapacityManagerDataExportsRequest>
  Model::DescribeCapacityManagerDataExportsOutcomeCallable DescribeCapacityManagerDataExportsCallable(
      const DescribeCapacityManagerDataExportsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityManagerDataExports, request);
  }

  /**
   * An Async wrapper for DescribeCapacityManagerDataExports that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DescribeCapacityManagerDataExportsRequestT = Model::DescribeCapacityManagerDataExportsRequest>
  void DescribeCapacityManagerDataExportsAsync(const DescribeCapacityManagerDataExportsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeCapacityManagerDataExportsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCapacityManagerDataExports, request, handler, context);
  }

  /**
   * <p>Describes a request to assign the billing of the unused capacity of a
   * Capacity Reservation. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/transfer-billing.html">
   * Billing assignment for shared Amazon EC2 Capacity
   * Reservations</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservationBillingRequests">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeCapacityReservationBillingRequestsOutcome DescribeCapacityReservationBillingRequests(
      const Model::DescribeCapacityReservationBillingRequestsRequest& request) const;

  /**
   * A Callable wrapper for DescribeCapacityReservationBillingRequests that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeCapacityReservationBillingRequestsRequestT = Model::DescribeCapacityReservationBillingRequestsRequest>
  Model::DescribeCapacityReservationBillingRequestsOutcomeCallable DescribeCapacityReservationBillingRequestsCallable(
      const DescribeCapacityReservationBillingRequestsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeCapacityReservationBillingRequests, request);
  }

  /**
   * An Async wrapper for DescribeCapacityReservationBillingRequests that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeCapacityReservationBillingRequestsRequestT = Model::DescribeCapacityReservationBillingRequestsRequest>
  void DescribeCapacityReservationBillingRequestsAsync(
      const DescribeCapacityReservationBillingRequestsRequestT& request,
      const DescribeCapacityReservationBillingRequestsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeCapacityReservationBillingRequests, request, handler, context);
  }

  /**
   * <p>Describes one or more Capacity Reservation Fleets.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservationFleets">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeCapacityReservationFleetsRequestT = Model::DescribeCapacityReservationFleetsRequest>
  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 <typename DescribeCapacityReservationFleetsRequestT = Model::DescribeCapacityReservationFleetsRequest>
  void DescribeCapacityReservationFleetsAsync(const DescribeCapacityReservationFleetsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeCapacityReservationFleetsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCapacityReservationFleets, request, handler, context);
  }

  /**
   * <p>Describes a tree-based hierarchy that represents the physical host placement
   * of your pending or active Capacity Reservations within an Availability Zone or
   * Local Zone. You can use this information to determine the relative proximity of
   * your capacity within the Amazon Web Services network before it is launched and
   * use this information to allocate capacity together to support your tightly
   * coupled workloads.</p> <p>Capacity Reservation topology is supported for
   * specific instance types only. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-topology-prerequisites.html">Prerequisites
   * for Amazon EC2 instance topology</a> in the <i>Amazon EC2 User Guide</i>.</p>
   *  <p>The Amazon EC2 API follows an eventual consistency model due to the
   * distributed nature of the system supporting it. As a result, when you call the
   * DescribeCapacityReservationTopology API command immediately after launching
   * instances, the response might return a <code>null</code> value for
   * <code>capacityBlockId</code> because the data might not have fully propagated
   * across all subsystems. For more information, see <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/eventual-consistency.html">Eventual
   * consistency in the Amazon EC2 API</a> in the <i>Amazon EC2 Developer
   * Guide</i>.</p>  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-topology.html">Amazon
   * EC2 topology</a> in the <i>Amazon EC2 User Guide</i>.</p> <p/><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservationTopology">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeCapacityReservationTopologyOutcome DescribeCapacityReservationTopology(
      const Model::DescribeCapacityReservationTopologyRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeCapacityReservationTopology that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeCapacityReservationTopologyRequestT = Model::DescribeCapacityReservationTopologyRequest>
  Model::DescribeCapacityReservationTopologyOutcomeCallable DescribeCapacityReservationTopologyCallable(
      const DescribeCapacityReservationTopologyRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityReservationTopology, request);
  }

  /**
   * An Async wrapper for DescribeCapacityReservationTopology that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeCapacityReservationTopologyRequestT = Model::DescribeCapacityReservationTopologyRequest>
  void DescribeCapacityReservationTopologyAsync(const DescribeCapacityReservationTopologyResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const DescribeCapacityReservationTopologyRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCapacityReservationTopology, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservations">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeCapacityReservationsRequestT = Model::DescribeCapacityReservationsRequest>
  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 <typename DescribeCapacityReservationsRequestT = Model::DescribeCapacityReservationsRequest>
  void DescribeCapacityReservationsAsync(const DescribeCapacityReservationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeCapacityReservationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCapacityReservations, request, handler, context);
  }

  /**
   * <p>Describes one or more of your carrier gateways.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCarrierGateways">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeCarrierGatewaysRequestT = Model::DescribeCarrierGatewaysRequest>
  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 <typename DescribeCarrierGatewaysRequestT = Model::DescribeCarrierGatewaysRequest>
  void DescribeCarrierGatewaysAsync(const DescribeCarrierGatewaysResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeCarrierGatewaysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCarrierGateways, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>Describes 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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClassicLinkInstances">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeClassicLinkInstancesRequestT = Model::DescribeClassicLinkInstancesRequest>
  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 <typename DescribeClassicLinkInstancesRequestT = Model::DescribeClassicLinkInstancesRequest>
  void DescribeClassicLinkInstancesAsync(const DescribeClassicLinkInstancesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeClassicLinkInstancesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeClassicLinkInstances, request, handler, context);
  }

  /**
   * <p>Describes the authorization rules for a specified Client VPN
   * endpoint.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnAuthorizationRules">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeClientVpnAuthorizationRulesRequestT = Model::DescribeClientVpnAuthorizationRulesRequest>
  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 <typename DescribeClientVpnAuthorizationRulesRequestT = Model::DescribeClientVpnAuthorizationRulesRequest>
  void DescribeClientVpnAuthorizationRulesAsync(const DescribeClientVpnAuthorizationRulesRequestT& request,
                                                const DescribeClientVpnAuthorizationRulesResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeClientVpnAuthorizationRules, request, handler, context);
  }

  /**
   * <p>Describes active client connections and connections that have been terminated
   * within the last 60 minutes for the specified Client VPN endpoint.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnConnections">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeClientVpnConnectionsRequestT = Model::DescribeClientVpnConnectionsRequest>
  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 <typename DescribeClientVpnConnectionsRequestT = Model::DescribeClientVpnConnectionsRequest>
  void DescribeClientVpnConnectionsAsync(const DescribeClientVpnConnectionsRequestT& request,
                                         const DescribeClientVpnConnectionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeClientVpnConnections, request, handler, context);
  }

  /**
   * <p>Describes one or more Client VPN endpoints in the account.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnEndpoints">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeClientVpnEndpointsRequestT = Model::DescribeClientVpnEndpointsRequest>
  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 <typename DescribeClientVpnEndpointsRequestT = Model::DescribeClientVpnEndpointsRequest>
  void DescribeClientVpnEndpointsAsync(const DescribeClientVpnEndpointsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeClientVpnEndpointsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeClientVpnEndpoints, request, handler, context);
  }

  /**
   * <p>Describes the routes for the specified Client VPN endpoint.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnRoutes">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeClientVpnRoutesRequestT = Model::DescribeClientVpnRoutesRequest>
  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 <typename DescribeClientVpnRoutesRequestT = Model::DescribeClientVpnRoutesRequest>
  void DescribeClientVpnRoutesAsync(const DescribeClientVpnRoutesRequestT& request,
                                    const DescribeClientVpnRoutesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeClientVpnRoutes, request, handler, context);
  }

  /**
   * <p>Describes the target networks associated with the specified Client VPN
   * endpoint.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnTargetNetworks">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeClientVpnTargetNetworksRequestT = Model::DescribeClientVpnTargetNetworksRequest>
  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 <typename DescribeClientVpnTargetNetworksRequestT = Model::DescribeClientVpnTargetNetworksRequest>
  void DescribeClientVpnTargetNetworksAsync(const DescribeClientVpnTargetNetworksRequestT& request,
                                            const DescribeClientVpnTargetNetworksResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeClientVpnTargetNetworks, request, handler, context);
  }

  /**
   * <p>Describes the specified customer-owned address pools or all of your
   * customer-owned address pools.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCoipPools">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeCoipPoolsRequestT = Model::DescribeCoipPoolsRequest>
  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 <typename DescribeCoipPoolsRequestT = Model::DescribeCoipPoolsRequest>
  void DescribeCoipPoolsAsync(const DescribeCoipPoolsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeCoipPoolsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCoipPools, request, handler, context);
  }

  /**
   * <p>Describes the specified conversion tasks or all your conversion tasks. For
   * more information, see the <a
   * href="https://docs.aws.amazon.com/vm-import/latest/userguide/">VM Import/Export
   * User Guide</a>.</p> <p>For information about the import manifest referenced by
   * this API action, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM
   * Import Manifest</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeConversionTasks">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeConversionTasksRequestT = Model::DescribeConversionTasksRequest>
  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 <typename DescribeConversionTasksRequestT = Model::DescribeConversionTasksRequest>
  void DescribeConversionTasksAsync(const DescribeConversionTasksResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeConversionTasksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeConversionTasks, request, handler, context);
  }

  /**
   * <p>Describes one or more of your VPN customer gateways.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web
   * Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCustomerGateways">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeCustomerGatewaysRequestT = Model::DescribeCustomerGatewaysRequest>
  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 <typename DescribeCustomerGatewaysRequestT = Model::DescribeCustomerGatewaysRequest>
  void DescribeCustomerGatewaysAsync(const DescribeCustomerGatewaysResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeCustomerGatewaysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCustomerGateways, request, handler, context);
  }

  /**
   * <p>Describes the metadata of an account status report, including the status of
   * the report.</p> <p>To view the full report, download it from the Amazon S3
   * bucket where it was saved. Reports are accessible only when they have the
   * <code>complete</code> status. Reports with other statuses (<code>running</code>,
   * <code>cancelled</code>, or <code>error</code>) are not available in the S3
   * bucket. For more information about downloading objects from an S3 bucket, see <a
   * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/download-objects.html">Downloading
   * objects</a> in the <i>Amazon Simple Storage Service User Guide</i>.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_declarative_status-report.html">Generating
   * the account status report for declarative policies</a> in the <i>Amazon Web
   * Services Organizations User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeDeclarativePoliciesReports">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeDeclarativePoliciesReportsOutcome DescribeDeclarativePoliciesReports(
      const Model::DescribeDeclarativePoliciesReportsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeDeclarativePoliciesReports that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DescribeDeclarativePoliciesReportsRequestT = Model::DescribeDeclarativePoliciesReportsRequest>
  Model::DescribeDeclarativePoliciesReportsOutcomeCallable DescribeDeclarativePoliciesReportsCallable(
      const DescribeDeclarativePoliciesReportsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeDeclarativePoliciesReports, request);
  }

  /**
   * An Async wrapper for DescribeDeclarativePoliciesReports that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DescribeDeclarativePoliciesReportsRequestT = Model::DescribeDeclarativePoliciesReportsRequest>
  void DescribeDeclarativePoliciesReportsAsync(const DescribeDeclarativePoliciesReportsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeDeclarativePoliciesReportsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeDeclarativePoliciesReports, request, handler, context);
  }

  /**
   * <p>Describes your DHCP option sets. The default is to describe all your DHCP
   * option sets. Alternatively, you can specify specific DHCP option set IDs or
   * filter the results to include only the DHCP option sets that match specific
   * criteria.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP
   * option sets</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeDhcpOptions">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeDhcpOptionsRequestT = Model::DescribeDhcpOptionsRequest>
  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 <typename DescribeDhcpOptionsRequestT = Model::DescribeDhcpOptionsRequest>
  void DescribeDhcpOptionsAsync(const DescribeDhcpOptionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeDhcpOptionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeDhcpOptions, request, handler, context);
  }

  /**
   * <p>Describes your egress-only internet gateways. The default is to describe all
   * your egress-only internet gateways. Alternatively, you can specify specific
   * egress-only internet gateway IDs or filter the results to include only the
   * egress-only internet gateways that match specific criteria.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeEgressOnlyInternetGateways">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeEgressOnlyInternetGatewaysRequestT = Model::DescribeEgressOnlyInternetGatewaysRequest>
  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 <typename DescribeEgressOnlyInternetGatewaysRequestT = Model::DescribeEgressOnlyInternetGatewaysRequest>
  void DescribeEgressOnlyInternetGatewaysAsync(const DescribeEgressOnlyInternetGatewaysResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeEgressOnlyInternetGatewaysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeEgressOnlyInternetGateways, request, handler, context);
  }

  /**
   *  <p>Amazon Elastic Graphics reached end of life on January 8, 2024.</p>
   *  <p>Describes the Elastic Graphics accelerator associated with your
   * instances.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeElasticGpus">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeElasticGpusRequestT = Model::DescribeElasticGpusRequest>
  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 <typename DescribeElasticGpusRequestT = Model::DescribeElasticGpusRequest>
  void DescribeElasticGpusAsync(const DescribeElasticGpusResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeElasticGpusRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeElasticGpus, request, handler, context);
  }

  /**
   * <p>Describes the specified export image tasks or all of your export image
   * tasks.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeExportImageTasks">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeExportImageTasksRequestT = Model::DescribeExportImageTasksRequest>
  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 <typename DescribeExportImageTasksRequestT = Model::DescribeExportImageTasksRequest>
  void DescribeExportImageTasksAsync(const DescribeExportImageTasksResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeExportImageTasksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeExportImageTasks, request, handler, context);
  }

  /**
   * <p>Describes the specified export instance tasks or all of your export instance
   * tasks.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeExportTasks">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeExportTasksRequestT = Model::DescribeExportTasksRequest>
  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 <typename DescribeExportTasksRequestT = Model::DescribeExportTasksRequest>
  void DescribeExportTasksAsync(const DescribeExportTasksResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeExportTasksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeExportTasks, request, handler, context);
  }

  /**
   * <p>Describe details for Windows AMIs that are configured for Windows fast
   * launch.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFastLaunchImages">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeFastLaunchImagesRequestT = Model::DescribeFastLaunchImagesRequest>
  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 <typename DescribeFastLaunchImagesRequestT = Model::DescribeFastLaunchImagesRequest>
  void DescribeFastLaunchImagesAsync(const DescribeFastLaunchImagesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeFastLaunchImagesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeFastLaunchImages, request, handler, context);
  }

  /**
   * <p>Describes the state of fast snapshot restores for your
   * snapshots.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFastSnapshotRestores">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeFastSnapshotRestoresRequestT = Model::DescribeFastSnapshotRestoresRequest>
  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 <typename DescribeFastSnapshotRestoresRequestT = Model::DescribeFastSnapshotRestoresRequest>
  void DescribeFastSnapshotRestoresAsync(const DescribeFastSnapshotRestoresResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeFastSnapshotRestoresRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeFastSnapshotRestores, request, handler, context);
  }

  /**
   * <p>Describes the events for the specified EC2 Fleet during the specified
   * time.</p> <p>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.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/fleet-monitor.html">Monitor
   * fleet events using Amazon EventBridge</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleetHistory">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeFleetHistoryRequestT = Model::DescribeFleetHistoryRequest>
  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 <typename DescribeFleetHistoryRequestT = Model::DescribeFleetHistoryRequest>
  void DescribeFleetHistoryAsync(const DescribeFleetHistoryRequestT& request, const DescribeFleetHistoryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeFleetHistory, request, handler, context);
  }

  /**
   * <p>Describes the running instances for the specified EC2 Fleet.</p>
   * <p>Currently, <code>DescribeFleetInstances</code> does not support fleets of
   * type <code>instant</code>. Instead, use <code>DescribeFleets</code>, specifying
   * the <code>instant</code> fleet ID in the request.</p>  <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#monitor-ec2-fleet">Describe
   * your EC2 Fleet</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleetInstances">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeFleetInstancesRequestT = Model::DescribeFleetInstancesRequest>
  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 <typename DescribeFleetInstancesRequestT = Model::DescribeFleetInstancesRequest>
  void DescribeFleetInstancesAsync(const DescribeFleetInstancesRequestT& request,
                                   const DescribeFleetInstancesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeFleetInstances, request, handler, context);
  }

  /**
   * <p>Describes the specified EC2 Fleet or all of your EC2 Fleets.</p>
   * <p>If a fleet is of type <code>instant</code>, you must specify the fleet ID in
   * the request, otherwise the fleet does not appear in the response.</p>
   *  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#monitor-ec2-fleet">Describe
   * your EC2 Fleet</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleets">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeFleetsRequestT = Model::DescribeFleetsRequest>
  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 <typename DescribeFleetsRequestT = Model::DescribeFleetsRequest>
  void DescribeFleetsAsync(const DescribeFleetsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeFleetsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeFleets, request, handler, context);
  }

  /**
   * <p>Describes one or more flow logs.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFlowLogs">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeFlowLogsRequestT = Model::DescribeFlowLogsRequest>
  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 <typename DescribeFlowLogsRequestT = Model::DescribeFlowLogsRequest>
  void DescribeFlowLogsAsync(const DescribeFlowLogsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeFlowLogsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeFlowLogs, request, handler, context);
  }

  /**
   * <p>Describes the specified attribute of the specified Amazon FPGA Image
   * (AFI).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFpgaImageAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeFpgaImageAttributeRequestT = Model::DescribeFpgaImageAttributeRequest>
  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 <typename DescribeFpgaImageAttributeRequestT = Model::DescribeFpgaImageAttributeRequest>
  void DescribeFpgaImageAttributeAsync(const DescribeFpgaImageAttributeRequestT& request,
                                       const DescribeFpgaImageAttributeResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeFpgaImageAttribute, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFpgaImages">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeFpgaImagesRequestT = Model::DescribeFpgaImagesRequest>
  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 <typename DescribeFpgaImagesRequestT = Model::DescribeFpgaImagesRequest>
  void DescribeFpgaImagesAsync(const DescribeFpgaImagesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DescribeFpgaImagesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeFpgaImages, request, handler, context);
  }

  /**
   * <p>Describes the Dedicated Host reservations that are available to purchase.</p>
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-overview.html">Dedicated
   * Hosts</a> in the <i>Amazon EC2 User Guide</i>. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHostReservationOfferings">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeHostReservationOfferingsRequestT = Model::DescribeHostReservationOfferingsRequest>
  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 <typename DescribeHostReservationOfferingsRequestT = Model::DescribeHostReservationOfferingsRequest>
  void DescribeHostReservationOfferingsAsync(const DescribeHostReservationOfferingsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DescribeHostReservationOfferingsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeHostReservationOfferings, request, handler, context);
  }

  /**
   * <p>Describes reservations that are associated with Dedicated Hosts in your
   * account.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHostReservations">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeHostReservationsRequestT = Model::DescribeHostReservationsRequest>
  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 <typename DescribeHostReservationsRequestT = Model::DescribeHostReservationsRequest>
  void DescribeHostReservationsAsync(const DescribeHostReservationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeHostReservationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeHostReservations, request, handler, context);
  }

  /**
   * <p>Describes the specified Dedicated Hosts or all your Dedicated Hosts.</p>
   * <p>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
   * <code>released</code>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHosts">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeHostsRequestT = Model::DescribeHostsRequest>
  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 <typename DescribeHostsRequestT = Model::DescribeHostsRequest>
  void DescribeHostsAsync(const DescribeHostsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const DescribeHostsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeHosts, request, handler, context);
  }

  /**
   * <p>Describes your IAM instance profile associations.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIamInstanceProfileAssociations">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeIamInstanceProfileAssociationsRequestT = Model::DescribeIamInstanceProfileAssociationsRequest>
  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 <typename DescribeIamInstanceProfileAssociationsRequestT = Model::DescribeIamInstanceProfileAssociationsRequest>
  void DescribeIamInstanceProfileAssociationsAsync(const DescribeIamInstanceProfileAssociationsResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const DescribeIamInstanceProfileAssociationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIamInstanceProfileAssociations, request, handler, context);
  }

  /**
   * <p>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.</p> <p>The
   * following resource types support longer IDs: <code>bundle</code> |
   * <code>conversion-task</code> | <code>customer-gateway</code> |
   * <code>dhcp-options</code> | <code>elastic-ip-allocation</code> |
   * <code>elastic-ip-association</code> | <code>export-task</code> |
   * <code>flow-log</code> | <code>image</code> | <code>import-task</code> |
   * <code>instance</code> | <code>internet-gateway</code> | <code>network-acl</code>
   * | <code>network-acl-association</code> | <code>network-interface</code> |
   * <code>network-interface-attachment</code> | <code>prefix-list</code> |
   * <code>reservation</code> | <code>route-table</code> |
   * <code>route-table-association</code> | <code>security-group</code> |
   * <code>snapshot</code> | <code>subnet</code> |
   * <code>subnet-cidr-block-association</code> | <code>volume</code> |
   * <code>vpc</code> | <code>vpc-cidr-block-association</code> |
   * <code>vpc-endpoint</code> | <code>vpc-peering-connection</code> |
   * <code>vpn-connection</code> | <code>vpn-gateway</code>. </p> <p>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 <a>ModifyIdFormat</a> 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 <code>Describe</code> command for the
   * resource type.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIdFormat">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeIdFormatRequestT = Model::DescribeIdFormatRequest>
  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 <typename DescribeIdFormatRequestT = Model::DescribeIdFormatRequest>
  void DescribeIdFormatAsync(const DescribeIdFormatResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeIdFormatRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIdFormat, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/resource-ids.html">Resource
   * IDs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. </p> <p>The
   * following resource types support longer IDs: <code>bundle</code> |
   * <code>conversion-task</code> | <code>customer-gateway</code> |
   * <code>dhcp-options</code> | <code>elastic-ip-allocation</code> |
   * <code>elastic-ip-association</code> | <code>export-task</code> |
   * <code>flow-log</code> | <code>image</code> | <code>import-task</code> |
   * <code>instance</code> | <code>internet-gateway</code> | <code>network-acl</code>
   * | <code>network-acl-association</code> | <code>network-interface</code> |
   * <code>network-interface-attachment</code> | <code>prefix-list</code> |
   * <code>reservation</code> | <code>route-table</code> |
   * <code>route-table-association</code> | <code>security-group</code> |
   * <code>snapshot</code> | <code>subnet</code> |
   * <code>subnet-cidr-block-association</code> | <code>volume</code> |
   * <code>vpc</code> | <code>vpc-cidr-block-association</code> |
   * <code>vpc-endpoint</code> | <code>vpc-peering-connection</code> |
   * <code>vpn-connection</code> | <code>vpn-gateway</code>. </p> <p>These settings
   * apply to the principal specified in the request. They do not apply to the
   * principal that makes the request.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIdentityIdFormat">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeIdentityIdFormatRequestT = Model::DescribeIdentityIdFormatRequest>
  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 <typename DescribeIdentityIdFormatRequestT = Model::DescribeIdentityIdFormatRequest>
  void DescribeIdentityIdFormatAsync(const DescribeIdentityIdFormatRequestT& request,
                                     const DescribeIdentityIdFormatResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeIdentityIdFormat, request, handler, context);
  }

  /**
   * <p>Describes the specified attribute of the specified AMI. You can specify only
   * one attribute at a time.</p>  <p>The order of the elements in the
   * response, including those within nested structures, might vary. Applications
   * should not assume the elements appear in a particular order.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImageAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeImageAttributeRequestT = Model::DescribeImageAttributeRequest>
  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 <typename DescribeImageAttributeRequestT = Model::DescribeImageAttributeRequest>
  void DescribeImageAttributeAsync(const DescribeImageAttributeRequestT& request,
                                   const DescribeImageAttributeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeImageAttribute, request, handler, context);
  }

  /**
   * <p>Describes your Amazon Web Services resources that are referencing the
   * specified images.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-ami-references.html">Identify
   * your resources referencing specified AMIs</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImageReferences">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeImageReferencesOutcome DescribeImageReferences(const Model::DescribeImageReferencesRequest& request) const;

  /**
   * A Callable wrapper for DescribeImageReferences that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeImageReferencesRequestT = Model::DescribeImageReferencesRequest>
  Model::DescribeImageReferencesOutcomeCallable DescribeImageReferencesCallable(const DescribeImageReferencesRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeImageReferences, request);
  }

  /**
   * An Async wrapper for DescribeImageReferences that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeImageReferencesRequestT = Model::DescribeImageReferencesRequest>
  void DescribeImageReferencesAsync(const DescribeImageReferencesRequestT& request,
                                    const DescribeImageReferencesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeImageReferences, request, handler, context);
  }

  /**
   * <p>Describes the entries in image usage reports, showing how your images are
   * used across other Amazon Web Services accounts.</p> <p>For more information, see
   * <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/your-ec2-ami-usage.html">View
   * your AMI usage</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImageUsageReportEntries">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeImageUsageReportEntriesOutcome DescribeImageUsageReportEntries(
      const Model::DescribeImageUsageReportEntriesRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeImageUsageReportEntries that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeImageUsageReportEntriesRequestT = Model::DescribeImageUsageReportEntriesRequest>
  Model::DescribeImageUsageReportEntriesOutcomeCallable DescribeImageUsageReportEntriesCallable(
      const DescribeImageUsageReportEntriesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeImageUsageReportEntries, request);
  }

  /**
   * An Async wrapper for DescribeImageUsageReportEntries that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DescribeImageUsageReportEntriesRequestT = Model::DescribeImageUsageReportEntriesRequest>
  void DescribeImageUsageReportEntriesAsync(const DescribeImageUsageReportEntriesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeImageUsageReportEntriesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeImageUsageReportEntries, request, handler, context);
  }

  /**
   * <p>Describes the configuration and status of image usage reports, filtered by
   * report IDs or image IDs.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/your-ec2-ami-usage.html">View
   * your AMI usage</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImageUsageReports">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeImageUsageReportsOutcome DescribeImageUsageReports(
      const Model::DescribeImageUsageReportsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeImageUsageReports that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeImageUsageReportsRequestT = Model::DescribeImageUsageReportsRequest>
  Model::DescribeImageUsageReportsOutcomeCallable DescribeImageUsageReportsCallable(
      const DescribeImageUsageReportsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeImageUsageReports, request);
  }

  /**
   * An Async wrapper for DescribeImageUsageReports that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeImageUsageReportsRequestT = Model::DescribeImageUsageReportsRequest>
  void DescribeImageUsageReportsAsync(const DescribeImageUsageReportsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeImageUsageReportsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeImageUsageReports, request, handler, context);
  }

  /**
   * <p>Describes the specified images (AMIs, AKIs, and ARIs) available to you or all
   * of the images available to you.</p> <p>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.</p>
   * <p>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.</p> <p>When Allowed
   * AMIs is set to <code>enabled</code>, only allowed images are returned in the
   * results, with the <code>imageAllowed</code> field set to <code>true</code> for
   * each image. In <code>audit-mode</code>, the <code>imageAllowed</code> field is
   * set to <code>true</code> for images that meet the account's Allowed AMIs
   * criteria, and <code>false</code> for images that don't meet the criteria. For
   * more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-allowed-amis.html">Allowed
   * AMIs</a>.</p> <p>The Amazon EC2 API follows an eventual consistency model. This
   * means that the result of an API command you run that creates or modifies
   * resources might not be immediately available to all subsequent commands you run.
   * For guidance on how to manage eventual consistency, see <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/eventual-consistency.html">Eventual
   * consistency in the Amazon EC2 API</a> in the <i>Amazon EC2 Developer
   * Guide</i>.</p>  <p>We strongly recommend using only paginated
   * requests. Unpaginated requests are susceptible to throttling and timeouts.</p>
   *   <p>The order of the elements in the response, including
   * those within nested structures, might vary. Applications should not assume the
   * elements appear in a particular order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImages">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeImagesRequestT = Model::DescribeImagesRequest>
  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 <typename DescribeImagesRequestT = Model::DescribeImagesRequest>
  void DescribeImagesAsync(const DescribeImagesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeImagesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeImages, request, handler, context);
  }

  /**
   * <p>Displays details about an import virtual machine or import snapshot tasks
   * that are already created.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImportImageTasks">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeImportImageTasksRequestT = Model::DescribeImportImageTasksRequest>
  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 <typename DescribeImportImageTasksRequestT = Model::DescribeImportImageTasksRequest>
  void DescribeImportImageTasksAsync(const DescribeImportImageTasksResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeImportImageTasksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeImportImageTasks, request, handler, context);
  }

  /**
   * <p>Describes your import snapshot tasks.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImportSnapshotTasks">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeImportSnapshotTasksRequestT = Model::DescribeImportSnapshotTasksRequest>
  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 <typename DescribeImportSnapshotTasksRequestT = Model::DescribeImportSnapshotTasksRequest>
  void DescribeImportSnapshotTasksAsync(const DescribeImportSnapshotTasksResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeImportSnapshotTasksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeImportSnapshotTasks, request, handler, context);
  }

  /**
   * <p>Describes the specified attribute of the specified instance. You can specify
   * only one attribute at a time. Available attributes include SQL license exemption
   * configuration for instances registered with the SQL LE service. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInstanceAttributeRequestT = Model::DescribeInstanceAttributeRequest>
  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 <typename DescribeInstanceAttributeRequestT = Model::DescribeInstanceAttributeRequest>
  void DescribeInstanceAttributeAsync(const DescribeInstanceAttributeRequestT& request,
                                      const DescribeInstanceAttributeResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeInstanceAttribute, request, handler, context);
  }

  /**
   * <p>Describes the specified EC2 Instance Connect Endpoints or all EC2 Instance
   * Connect Endpoints.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceConnectEndpoints">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInstanceConnectEndpointsRequestT = Model::DescribeInstanceConnectEndpointsRequest>
  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 <typename DescribeInstanceConnectEndpointsRequestT = Model::DescribeInstanceConnectEndpointsRequest>
  void DescribeInstanceConnectEndpointsAsync(const DescribeInstanceConnectEndpointsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DescribeInstanceConnectEndpointsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceConnectEndpoints, request, handler, context);
  }

  /**
   * <p>Describes the credit option for CPU usage of the specified burstable
   * performance instances. The credit options are <code>standard</code> and
   * <code>unlimited</code>.</p> <p>If you do not specify an instance ID, Amazon EC2
   * returns burstable performance instances with the <code>unlimited</code> credit
   * option, as well as instances that were previously configured as T2, T3, and T3a
   * with the <code>unlimited</code> credit option. For example, if you resize a T2
   * instance, while it is configured as <code>unlimited</code>, to an M4 instance,
   * Amazon EC2 returns the M4 instance.</p> <p>If you specify one or more instance
   * IDs, Amazon EC2 returns the credit option (<code>standard</code> or
   * <code>unlimited</code>) 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.</p> <p>Recently terminated instances might appear in the
   * returned results. This interval is usually less than one hour.</p> <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html">Burstable
   * performance instances</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceCreditSpecifications">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInstanceCreditSpecificationsRequestT = Model::DescribeInstanceCreditSpecificationsRequest>
  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 <typename DescribeInstanceCreditSpecificationsRequestT = Model::DescribeInstanceCreditSpecificationsRequest>
  void DescribeInstanceCreditSpecificationsAsync(const DescribeInstanceCreditSpecificationsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeInstanceCreditSpecificationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceCreditSpecifications, request, handler, context);
  }

  /**
   * <p>Describes the tag keys that are registered to appear in scheduled event
   * notifications for resources in the current Region.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceEventNotificationAttributes">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInstanceEventNotificationAttributesRequestT = Model::DescribeInstanceEventNotificationAttributesRequest>
  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 <typename DescribeInstanceEventNotificationAttributesRequestT = Model::DescribeInstanceEventNotificationAttributesRequest>
  void DescribeInstanceEventNotificationAttributesAsync(const DescribeInstanceEventNotificationAttributesResponseReceivedHandler& handler,
                                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                        const DescribeInstanceEventNotificationAttributesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceEventNotificationAttributes, request, handler, context);
  }

  /**
   * <p>Describes the specified event windows or all event windows.</p> <p>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. </p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
   * event windows for scheduled events</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceEventWindows">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInstanceEventWindowsRequestT = Model::DescribeInstanceEventWindowsRequest>
  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 <typename DescribeInstanceEventWindowsRequestT = Model::DescribeInstanceEventWindowsRequest>
  void DescribeInstanceEventWindowsAsync(const DescribeInstanceEventWindowsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeInstanceEventWindowsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceEventWindows, request, handler, context);
  }

  /**
   * <p>Describes the AMI that was used to launch an instance, even if the AMI is
   * deprecated, deregistered, made private (no longer public or shared with your
   * account), or not allowed.</p> <p>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.</p> <p>If you
   * specify an instance ID that is not valid, an instance that doesn't exist, or an
   * instance that you do not own, an error (<code>InvalidInstanceID.NotFound</code>)
   * is returned.</p> <p>Recently terminated instances might appear in the returned
   * results. This interval is usually less than one hour.</p> <p>In the rare case
   * where an Availability Zone is experiencing a service disruption and you specify
   * instance IDs that are in the affected Availability Zone, or do not specify any
   * instance IDs at all, the call fails. If you specify only instance IDs that are
   * in an unaffected Availability Zone, the call works normally.</p>  <p>The
   * order of the elements in the response, including those within nested structures,
   * might vary. Applications should not assume the elements appear in a particular
   * order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceImageMetadata">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeInstanceImageMetadataOutcome DescribeInstanceImageMetadata(
      const Model::DescribeInstanceImageMetadataRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeInstanceImageMetadata that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeInstanceImageMetadataRequestT = Model::DescribeInstanceImageMetadataRequest>
  Model::DescribeInstanceImageMetadataOutcomeCallable DescribeInstanceImageMetadataCallable(
      const DescribeInstanceImageMetadataRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceImageMetadata, request);
  }

  /**
   * An Async wrapper for DescribeInstanceImageMetadata that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeInstanceImageMetadataRequestT = Model::DescribeInstanceImageMetadataRequest>
  void DescribeInstanceImageMetadataAsync(const DescribeInstanceImageMetadataResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeInstanceImageMetadataRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceImageMetadata, request, handler, context);
  }

  /**
   * <p>Describes the historical SQL Server High Availability states for Amazon EC2
   * instances that are enabled for Amazon EC2 High Availability for SQL Server
   * monitoring.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceSqlHaHistoryStates">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeInstanceSqlHaHistoryStatesOutcome DescribeInstanceSqlHaHistoryStates(
      const Model::DescribeInstanceSqlHaHistoryStatesRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeInstanceSqlHaHistoryStates that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DescribeInstanceSqlHaHistoryStatesRequestT = Model::DescribeInstanceSqlHaHistoryStatesRequest>
  Model::DescribeInstanceSqlHaHistoryStatesOutcomeCallable DescribeInstanceSqlHaHistoryStatesCallable(
      const DescribeInstanceSqlHaHistoryStatesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceSqlHaHistoryStates, request);
  }

  /**
   * An Async wrapper for DescribeInstanceSqlHaHistoryStates that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DescribeInstanceSqlHaHistoryStatesRequestT = Model::DescribeInstanceSqlHaHistoryStatesRequest>
  void DescribeInstanceSqlHaHistoryStatesAsync(const DescribeInstanceSqlHaHistoryStatesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeInstanceSqlHaHistoryStatesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceSqlHaHistoryStates, request, handler, context);
  }

  /**
   * <p>Describes the SQL Server High Availability states for Amazon EC2 instances
   * that are enabled for Amazon EC2 High Availability for SQL Server
   * monitoring.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceSqlHaStates">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeInstanceSqlHaStatesOutcome DescribeInstanceSqlHaStates(
      const Model::DescribeInstanceSqlHaStatesRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeInstanceSqlHaStates that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeInstanceSqlHaStatesRequestT = Model::DescribeInstanceSqlHaStatesRequest>
  Model::DescribeInstanceSqlHaStatesOutcomeCallable DescribeInstanceSqlHaStatesCallable(
      const DescribeInstanceSqlHaStatesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceSqlHaStates, request);
  }

  /**
   * An Async wrapper for DescribeInstanceSqlHaStates that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeInstanceSqlHaStatesRequestT = Model::DescribeInstanceSqlHaStatesRequest>
  void DescribeInstanceSqlHaStatesAsync(const DescribeInstanceSqlHaStatesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeInstanceSqlHaStatesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceSqlHaStates, request, handler, context);
  }

  /**
   * <p>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.</p> <p>Instance status includes the
   * following components:</p> <ul> <li> <p> <b>Status checks</b> - Amazon EC2
   * performs status checks on running EC2 instances to identify hardware and
   * software issues. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-system-instance-status-check.html">Status
   * checks for your instances</a> and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstances.html">Troubleshoot
   * instances with failed status checks</a> in the <i>Amazon EC2 User Guide</i>.</p>
   * </li> <li> <p> <b>Scheduled events</b> - 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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html">Scheduled
   * events for your instances</a> in the <i>Amazon EC2 User Guide</i>.</p> </li>
   * <li> <p> <b>Instance state</b> - You can manage your instances from the moment
   * you launch them through their termination. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Instance
   * lifecycle</a> in the <i>Amazon EC2 User Guide</i>.</p> </li> </ul> <p>The Amazon
   * EC2 API follows an eventual consistency model. This means that the result of an
   * API command you run that creates or modifies resources might not be immediately
   * available to all subsequent commands you run. For guidance on how to manage
   * eventual consistency, see <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/eventual-consistency.html">Eventual
   * consistency in the Amazon EC2 API</a> in the <i>Amazon EC2 Developer
   * Guide</i>.</p>  <p>The order of the elements in the response, including
   * those within nested structures, might vary. Applications should not assume the
   * elements appear in a particular order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceStatus">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInstanceStatusRequestT = Model::DescribeInstanceStatusRequest>
  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 <typename DescribeInstanceStatusRequestT = Model::DescribeInstanceStatusRequest>
  void DescribeInstanceStatusAsync(const DescribeInstanceStatusResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeInstanceStatusRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceStatus, request, handler, context);
  }

  /**
   * <p>Describes a tree-based hierarchy that represents the physical host placement
   * of your EC2 instances within an Availability Zone or Local Zone. You can use
   * this information to determine the relative proximity of your EC2 instances
   * within the Amazon Web Services network to support your tightly coupled
   * workloads.</p> <p>Instance topology is supported for specific instance types
   * only. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-topology-prerequisites.html">Prerequisites
   * for Amazon EC2 instance topology</a> in the <i>Amazon EC2 User Guide</i>.</p>
   *  <p>The Amazon EC2 API follows an eventual consistency model due to the
   * distributed nature of the system supporting it. As a result, when you call the
   * DescribeInstanceTopology API command immediately after launching instances, the
   * response might return a <code>null</code> value for <code>capacityBlockId</code>
   * because the data might not have fully propagated across all subsystems. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/eventual-consistency.html">Eventual
   * consistency in the Amazon EC2 API</a> in the <i>Amazon EC2 Developer
   * Guide</i>.</p>  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-topology.html">Amazon
   * EC2 topology</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceTopology">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeInstanceTopologyOutcome DescribeInstanceTopology(const Model::DescribeInstanceTopologyRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeInstanceTopology that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeInstanceTopologyRequestT = Model::DescribeInstanceTopologyRequest>
  Model::DescribeInstanceTopologyOutcomeCallable DescribeInstanceTopologyCallable(
      const DescribeInstanceTopologyRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceTopology, request);
  }

  /**
   * An Async wrapper for DescribeInstanceTopology that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeInstanceTopologyRequestT = Model::DescribeInstanceTopologyRequest>
  void DescribeInstanceTopologyAsync(const DescribeInstanceTopologyResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeInstanceTopologyRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceTopology, request, handler, context);
  }

  /**
   * <p>Lists the instance types that are offered for the specified location. If no
   * location is specified, the default is to list the instance types that are
   * offered in the current Region.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceTypeOfferings">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInstanceTypeOfferingsRequestT = Model::DescribeInstanceTypeOfferingsRequest>
  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 <typename DescribeInstanceTypeOfferingsRequestT = Model::DescribeInstanceTypeOfferingsRequest>
  void DescribeInstanceTypeOfferingsAsync(const DescribeInstanceTypeOfferingsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeInstanceTypeOfferingsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceTypeOfferings, request, handler, context);
  }

  /**
   * <p>Describes the specified instance types. By default, all instance types for
   * the current Region are described. Alternatively, you can filter the
   * results.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceTypes">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInstanceTypesRequestT = Model::DescribeInstanceTypesRequest>
  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 <typename DescribeInstanceTypesRequestT = Model::DescribeInstanceTypesRequest>
  void DescribeInstanceTypesAsync(const DescribeInstanceTypesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeInstanceTypesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstanceTypes, request, handler, context);
  }

  /**
   * <p>Describes the specified instances or all instances.</p> <p>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.</p> <p>The response includes SQL license exemption
   * status information for instances registered with the SQL LE service, providing
   * visibility into license exemption configuration and status.</p> <p>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.</p>
   * <p>Recently terminated instances might appear in the returned results. This
   * interval is usually less than one hour.</p> <p>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.</p> <p>The
   * Amazon EC2 API follows an eventual consistency model. This means that the result
   * of an API command you run that creates or modifies resources might not be
   * immediately available to all subsequent commands you run. For guidance on how to
   * manage eventual consistency, see <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/eventual-consistency.html">Eventual
   * consistency in the Amazon EC2 API</a> in the <i>Amazon EC2 Developer
   * Guide</i>.</p>  <p>We strongly recommend using only paginated
   * requests. Unpaginated requests are susceptible to throttling and timeouts.</p>
   *   <p>The order of the elements in the response, including
   * those within nested structures, might vary. Applications should not assume the
   * elements appear in a particular order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstances">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInstancesRequestT = Model::DescribeInstancesRequest>
  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 <typename DescribeInstancesRequestT = Model::DescribeInstancesRequest>
  void DescribeInstancesAsync(const DescribeInstancesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeInstancesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInstances, request, handler, context);
  }

  /**
   * <p>Describes your internet gateways. The default is to describe all your
   * internet gateways. Alternatively, you can specify specific internet gateway IDs
   * or filter the results to include only the internet gateways that match specific
   * criteria.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInternetGateways">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeInternetGatewaysRequestT = Model::DescribeInternetGatewaysRequest>
  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 <typename DescribeInternetGatewaysRequestT = Model::DescribeInternetGatewaysRequest>
  void DescribeInternetGatewaysAsync(const DescribeInternetGatewaysResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeInternetGatewaysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeInternetGateways, request, handler, context);
  }

  /**
   * <p>Describes your Autonomous System Numbers (ASNs), their provisioning statuses,
   * and the BYOIP CIDRs with which they are associated. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoasn.html">Tutorial:
   * Bring your ASN to IPAM</a> in the <i>Amazon VPC IPAM guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamByoasn">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeIpamByoasnOutcome DescribeIpamByoasn(const Model::DescribeIpamByoasnRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeIpamByoasn that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeIpamByoasnRequestT = Model::DescribeIpamByoasnRequest>
  Model::DescribeIpamByoasnOutcomeCallable DescribeIpamByoasnCallable(const DescribeIpamByoasnRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamByoasn, request);
  }

  /**
   * An Async wrapper for DescribeIpamByoasn that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename DescribeIpamByoasnRequestT = Model::DescribeIpamByoasnRequest>
  void DescribeIpamByoasnAsync(const DescribeIpamByoasnResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DescribeIpamByoasnRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamByoasn, request, handler, context);
  }

  /**
   * <p>Describe verification tokens.</p> <p>A verification token is an Amazon Web
   * Services-generated random value that you can use to prove ownership of an
   * external resource. For example, you can use a verification token to validate
   * that you control a public IP address range when you bring an IP address range to
   * Amazon Web Services (BYOIP). </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamExternalResourceVerificationTokens">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeIpamExternalResourceVerificationTokensOutcome DescribeIpamExternalResourceVerificationTokens(
      const Model::DescribeIpamExternalResourceVerificationTokensRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeIpamExternalResourceVerificationTokens that returns a future to the operation so that it can be executed
   * in parallel to other requests.
   */
  template <typename DescribeIpamExternalResourceVerificationTokensRequestT = Model::DescribeIpamExternalResourceVerificationTokensRequest>
  Model::DescribeIpamExternalResourceVerificationTokensOutcomeCallable DescribeIpamExternalResourceVerificationTokensCallable(
      const DescribeIpamExternalResourceVerificationTokensRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamExternalResourceVerificationTokens, request);
  }

  /**
   * An Async wrapper for DescribeIpamExternalResourceVerificationTokens that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  template <typename DescribeIpamExternalResourceVerificationTokensRequestT = Model::DescribeIpamExternalResourceVerificationTokensRequest>
  void DescribeIpamExternalResourceVerificationTokensAsync(
      const DescribeIpamExternalResourceVerificationTokensResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DescribeIpamExternalResourceVerificationTokensRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamExternalResourceVerificationTokens, request, handler, context);
  }

  /**
   * <p>Describes one or more IPAM policies.</p> <p>An IPAM policy is a set of rules
   * that define how public IPv4 addresses from IPAM pools are allocated to Amazon
   * Web Services resources. Each rule maps an Amazon Web Services service to IPAM
   * pools that the service will use to get IP addresses. A single policy can have
   * multiple rules and be applied to multiple Amazon Web Services Regions. If the
   * IPAM pool run out of addresses then the services fallback to Amazon-provided IP
   * addresses. A policy can be applied to an individual Amazon Web Services account
   * or an entity within Amazon Web Services Organizations.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamPolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeIpamPoliciesOutcome DescribeIpamPolicies(const Model::DescribeIpamPoliciesRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeIpamPolicies that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeIpamPoliciesRequestT = Model::DescribeIpamPoliciesRequest>
  Model::DescribeIpamPoliciesOutcomeCallable DescribeIpamPoliciesCallable(const DescribeIpamPoliciesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamPolicies, request);
  }

  /**
   * An Async wrapper for DescribeIpamPolicies that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeIpamPoliciesRequestT = Model::DescribeIpamPoliciesRequest>
  void DescribeIpamPoliciesAsync(const DescribeIpamPoliciesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeIpamPoliciesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamPolicies, request, handler, context);
  }

  /**
   * <p>Get information about your IPAM pools.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamPools">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeIpamPoolsRequestT = Model::DescribeIpamPoolsRequest>
  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 <typename DescribeIpamPoolsRequestT = Model::DescribeIpamPoolsRequest>
  void DescribeIpamPoolsAsync(const DescribeIpamPoolsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeIpamPoolsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamPools, request, handler, context);
  }

  /**
   * <p>Describes one or more IPAM prefix list resolver Targets. Use this operation
   * to view the configuration and status of resolver targets.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamPrefixListResolverTargets">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeIpamPrefixListResolverTargetsOutcome DescribeIpamPrefixListResolverTargets(
      const Model::DescribeIpamPrefixListResolverTargetsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeIpamPrefixListResolverTargets that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeIpamPrefixListResolverTargetsRequestT = Model::DescribeIpamPrefixListResolverTargetsRequest>
  Model::DescribeIpamPrefixListResolverTargetsOutcomeCallable DescribeIpamPrefixListResolverTargetsCallable(
      const DescribeIpamPrefixListResolverTargetsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamPrefixListResolverTargets, request);
  }

  /**
   * An Async wrapper for DescribeIpamPrefixListResolverTargets that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeIpamPrefixListResolverTargetsRequestT = Model::DescribeIpamPrefixListResolverTargetsRequest>
  void DescribeIpamPrefixListResolverTargetsAsync(const DescribeIpamPrefixListResolverTargetsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const DescribeIpamPrefixListResolverTargetsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamPrefixListResolverTargets, request, handler, context);
  }

  /**
   * <p>Describes one or more IPAM prefix list resolvers. Use this operation to view
   * the configuration, status, and properties of your resolvers.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamPrefixListResolvers">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeIpamPrefixListResolversOutcome DescribeIpamPrefixListResolvers(
      const Model::DescribeIpamPrefixListResolversRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeIpamPrefixListResolvers that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeIpamPrefixListResolversRequestT = Model::DescribeIpamPrefixListResolversRequest>
  Model::DescribeIpamPrefixListResolversOutcomeCallable DescribeIpamPrefixListResolversCallable(
      const DescribeIpamPrefixListResolversRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamPrefixListResolvers, request);
  }

  /**
   * An Async wrapper for DescribeIpamPrefixListResolvers that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DescribeIpamPrefixListResolversRequestT = Model::DescribeIpamPrefixListResolversRequest>
  void DescribeIpamPrefixListResolversAsync(const DescribeIpamPrefixListResolversResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeIpamPrefixListResolversRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamPrefixListResolvers, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamResourceDiscoveries">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeIpamResourceDiscoveriesRequestT = Model::DescribeIpamResourceDiscoveriesRequest>
  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 <typename DescribeIpamResourceDiscoveriesRequestT = Model::DescribeIpamResourceDiscoveriesRequest>
  void DescribeIpamResourceDiscoveriesAsync(const DescribeIpamResourceDiscoveriesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeIpamResourceDiscoveriesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamResourceDiscoveries, request, handler, context);
  }

  /**
   * <p>Describes resource discovery association with an Amazon VPC IPAM. An
   * associated resource discovery is a resource discovery that has been associated
   * with an IPAM..</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamResourceDiscoveryAssociations">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeIpamResourceDiscoveryAssociationsRequestT = Model::DescribeIpamResourceDiscoveryAssociationsRequest>
  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 <typename DescribeIpamResourceDiscoveryAssociationsRequestT = Model::DescribeIpamResourceDiscoveryAssociationsRequest>
  void DescribeIpamResourceDiscoveryAssociationsAsync(const DescribeIpamResourceDiscoveryAssociationsResponseReceivedHandler& handler,
                                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                      const DescribeIpamResourceDiscoveryAssociationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamResourceDiscoveryAssociations, request, handler, context);
  }

  /**
   * <p>Get information about your IPAM scopes.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamScopes">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeIpamScopesRequestT = Model::DescribeIpamScopesRequest>
  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 <typename DescribeIpamScopesRequestT = Model::DescribeIpamScopesRequest>
  void DescribeIpamScopesAsync(const DescribeIpamScopesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DescribeIpamScopesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamScopes, request, handler, context);
  }

  /**
   * <p>Get information about your IPAM pools.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/what-is-it-ipam.html">What is
   * IPAM?</a> in the <i>Amazon VPC IPAM User Guide</i>. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpams">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeIpamsRequestT = Model::DescribeIpamsRequest>
  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 <typename DescribeIpamsRequestT = Model::DescribeIpamsRequest>
  void DescribeIpamsAsync(const DescribeIpamsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const DescribeIpamsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpams, request, handler, context);
  }

  /**
   * <p>Describes your IPv6 address pools.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpv6Pools">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeIpv6PoolsRequestT = Model::DescribeIpv6PoolsRequest>
  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 <typename DescribeIpv6PoolsRequestT = Model::DescribeIpv6PoolsRequest>
  void DescribeIpv6PoolsAsync(const DescribeIpv6PoolsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeIpv6PoolsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpv6Pools, request, handler, context);
  }

  /**
   * <p>Describes the specified key pairs or all of your key pairs.</p> <p>For more
   * information about key pairs, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Amazon
   * EC2 key pairs</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeKeyPairs">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeKeyPairsRequestT = Model::DescribeKeyPairsRequest>
  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 <typename DescribeKeyPairsRequestT = Model::DescribeKeyPairsRequest>
  void DescribeKeyPairsAsync(const DescribeKeyPairsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeKeyPairsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeKeyPairs, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLaunchTemplateVersions">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeLaunchTemplateVersionsRequestT = Model::DescribeLaunchTemplateVersionsRequest>
  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 <typename DescribeLaunchTemplateVersionsRequestT = Model::DescribeLaunchTemplateVersionsRequest>
  void DescribeLaunchTemplateVersionsAsync(const DescribeLaunchTemplateVersionsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeLaunchTemplateVersionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeLaunchTemplateVersions, request, handler, context);
  }

  /**
   * <p>Describes one or more launch templates.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLaunchTemplates">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeLaunchTemplatesRequestT = Model::DescribeLaunchTemplatesRequest>
  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 <typename DescribeLaunchTemplatesRequestT = Model::DescribeLaunchTemplatesRequest>
  void DescribeLaunchTemplatesAsync(const DescribeLaunchTemplatesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeLaunchTemplatesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeLaunchTemplates, request, handler, context);
  }

  /**
   * <p>Describes the associations between virtual interface groups and local gateway
   * route tables.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequestT =
                Model::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest>
  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 <typename DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequestT =
                Model::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest>
  void DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsAsync(
      const DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations, request, handler, context);
  }

  /**
   * <p>Describes the specified associations between VPCs and local gateway route
   * tables.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTableVpcAssociations">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeLocalGatewayRouteTableVpcAssociationsRequestT = Model::DescribeLocalGatewayRouteTableVpcAssociationsRequest>
  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 <typename DescribeLocalGatewayRouteTableVpcAssociationsRequestT = Model::DescribeLocalGatewayRouteTableVpcAssociationsRequest>
  void DescribeLocalGatewayRouteTableVpcAssociationsAsync(
      const DescribeLocalGatewayRouteTableVpcAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DescribeLocalGatewayRouteTableVpcAssociationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeLocalGatewayRouteTableVpcAssociations, request, handler, context);
  }

  /**
   * <p>Describes one or more local gateway route tables. By default, all local
   * gateway route tables are described. Alternatively, you can filter the
   * results.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTables">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeLocalGatewayRouteTablesRequestT = Model::DescribeLocalGatewayRouteTablesRequest>
  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 <typename DescribeLocalGatewayRouteTablesRequestT = Model::DescribeLocalGatewayRouteTablesRequest>
  void DescribeLocalGatewayRouteTablesAsync(const DescribeLocalGatewayRouteTablesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeLocalGatewayRouteTablesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeLocalGatewayRouteTables, request, handler, context);
  }

  /**
   * <p>Describes the specified local gateway virtual interface groups.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayVirtualInterfaceGroups">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeLocalGatewayVirtualInterfaceGroupsRequestT = Model::DescribeLocalGatewayVirtualInterfaceGroupsRequest>
  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 <typename DescribeLocalGatewayVirtualInterfaceGroupsRequestT = Model::DescribeLocalGatewayVirtualInterfaceGroupsRequest>
  void DescribeLocalGatewayVirtualInterfaceGroupsAsync(const DescribeLocalGatewayVirtualInterfaceGroupsResponseReceivedHandler& handler,
                                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                       const DescribeLocalGatewayVirtualInterfaceGroupsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeLocalGatewayVirtualInterfaceGroups, request, handler, context);
  }

  /**
   * <p>Describes the specified local gateway virtual interfaces.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayVirtualInterfaces">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeLocalGatewayVirtualInterfacesRequestT = Model::DescribeLocalGatewayVirtualInterfacesRequest>
  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 <typename DescribeLocalGatewayVirtualInterfacesRequestT = Model::DescribeLocalGatewayVirtualInterfacesRequest>
  void DescribeLocalGatewayVirtualInterfacesAsync(const DescribeLocalGatewayVirtualInterfacesResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const DescribeLocalGatewayVirtualInterfacesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeLocalGatewayVirtualInterfaces, request, handler, context);
  }

  /**
   * <p>Describes one or more local gateways. By default, all local gateways are
   * described. Alternatively, you can filter the results.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGateways">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeLocalGatewaysRequestT = Model::DescribeLocalGatewaysRequest>
  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 <typename DescribeLocalGatewaysRequestT = Model::DescribeLocalGatewaysRequest>
  void DescribeLocalGatewaysAsync(const DescribeLocalGatewaysResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeLocalGatewaysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeLocalGateways, request, handler, context);
  }

  /**
   * <p>Describes the lock status for a snapshot.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLockedSnapshots">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeLockedSnapshotsOutcome DescribeLockedSnapshots(const Model::DescribeLockedSnapshotsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeLockedSnapshots that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeLockedSnapshotsRequestT = Model::DescribeLockedSnapshotsRequest>
  Model::DescribeLockedSnapshotsOutcomeCallable DescribeLockedSnapshotsCallable(const DescribeLockedSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLockedSnapshots, request);
  }

  /**
   * An Async wrapper for DescribeLockedSnapshots that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeLockedSnapshotsRequestT = Model::DescribeLockedSnapshotsRequest>
  void DescribeLockedSnapshotsAsync(const DescribeLockedSnapshotsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeLockedSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeLockedSnapshots, request, handler, context);
  }

  /**
   * <p>Describes the specified EC2 Mac Dedicated Host or all of your EC2 Mac
   * Dedicated Hosts.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeMacHosts">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeMacHostsOutcome DescribeMacHosts(const Model::DescribeMacHostsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeMacHosts that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeMacHostsRequestT = Model::DescribeMacHostsRequest>
  Model::DescribeMacHostsOutcomeCallable DescribeMacHostsCallable(const DescribeMacHostsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeMacHosts, request);
  }

  /**
   * An Async wrapper for DescribeMacHosts that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename DescribeMacHostsRequestT = Model::DescribeMacHostsRequest>
  void DescribeMacHostsAsync(const DescribeMacHostsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeMacHostsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeMacHosts, request, handler, context);
  }

  /**
   * <p>Describes a System Integrity Protection (SIP) modification task or volume
   * ownership delegation task for an Amazon EC2 Mac instance. For more information,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/mac-sip-settings.html#mac-sip-configure">Configure
   * SIP for Amazon EC2 instances</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeMacModificationTasks">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeMacModificationTasksOutcome DescribeMacModificationTasks(
      const Model::DescribeMacModificationTasksRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeMacModificationTasks that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeMacModificationTasksRequestT = Model::DescribeMacModificationTasksRequest>
  Model::DescribeMacModificationTasksOutcomeCallable DescribeMacModificationTasksCallable(
      const DescribeMacModificationTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeMacModificationTasks, request);
  }

  /**
   * An Async wrapper for DescribeMacModificationTasks that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeMacModificationTasksRequestT = Model::DescribeMacModificationTasksRequest>
  void DescribeMacModificationTasksAsync(const DescribeMacModificationTasksResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeMacModificationTasksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeMacModificationTasks, request, handler, context);
  }

  /**
   * <p>Describes your managed prefix lists and any Amazon Web Services-managed
   * prefix lists.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeManagedPrefixLists">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeManagedPrefixListsRequestT = Model::DescribeManagedPrefixListsRequest>
  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 <typename DescribeManagedPrefixListsRequestT = Model::DescribeManagedPrefixListsRequest>
  void DescribeManagedPrefixListsAsync(const DescribeManagedPrefixListsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeManagedPrefixListsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeManagedPrefixLists, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeMovingAddresses">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeMovingAddressesRequestT = Model::DescribeMovingAddressesRequest>
  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 <typename DescribeMovingAddressesRequestT = Model::DescribeMovingAddressesRequest>
  void DescribeMovingAddressesAsync(const DescribeMovingAddressesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeMovingAddressesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeMovingAddresses, request, handler, context);
  }

  /**
   * <p>Describes your NAT gateways. The default is to describe all your NAT
   * gateways. Alternatively, you can specify specific NAT gateway IDs or filter the
   * results to include only the NAT gateways that match specific
   * criteria.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNatGateways">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeNatGatewaysRequestT = Model::DescribeNatGatewaysRequest>
  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 <typename DescribeNatGatewaysRequestT = Model::DescribeNatGatewaysRequest>
  void DescribeNatGatewaysAsync(const DescribeNatGatewaysResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeNatGatewaysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeNatGateways, request, handler, context);
  }

  /**
   * <p>Describes your network ACLs. The default is to describe all your network
   * ACLs. Alternatively, you can specify specific network ACL IDs or filter the
   * results to include only the network ACLs that match specific criteria.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
   * ACLs</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkAcls">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeNetworkAclsRequestT = Model::DescribeNetworkAclsRequest>
  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 <typename DescribeNetworkAclsRequestT = Model::DescribeNetworkAclsRequest>
  void DescribeNetworkAclsAsync(const DescribeNetworkAclsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeNetworkAclsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeNetworkAcls, request, handler, context);
  }

  /**
   * <p>Describes the specified Network Access Scope analyses.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAccessScopeAnalyses">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeNetworkInsightsAccessScopeAnalysesRequestT = Model::DescribeNetworkInsightsAccessScopeAnalysesRequest>
  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 <typename DescribeNetworkInsightsAccessScopeAnalysesRequestT = Model::DescribeNetworkInsightsAccessScopeAnalysesRequest>
  void DescribeNetworkInsightsAccessScopeAnalysesAsync(const DescribeNetworkInsightsAccessScopeAnalysesResponseReceivedHandler& handler,
                                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                       const DescribeNetworkInsightsAccessScopeAnalysesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeNetworkInsightsAccessScopeAnalyses, request, handler, context);
  }

  /**
   * <p>Describes the specified Network Access Scopes.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAccessScopes">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeNetworkInsightsAccessScopesRequestT = Model::DescribeNetworkInsightsAccessScopesRequest>
  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 <typename DescribeNetworkInsightsAccessScopesRequestT = Model::DescribeNetworkInsightsAccessScopesRequest>
  void DescribeNetworkInsightsAccessScopesAsync(const DescribeNetworkInsightsAccessScopesResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const DescribeNetworkInsightsAccessScopesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeNetworkInsightsAccessScopes, request, handler, context);
  }

  /**
   * <p>Describes one or more of your network insights analyses.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAnalyses">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeNetworkInsightsAnalysesRequestT = Model::DescribeNetworkInsightsAnalysesRequest>
  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 <typename DescribeNetworkInsightsAnalysesRequestT = Model::DescribeNetworkInsightsAnalysesRequest>
  void DescribeNetworkInsightsAnalysesAsync(const DescribeNetworkInsightsAnalysesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeNetworkInsightsAnalysesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeNetworkInsightsAnalyses, request, handler, context);
  }

  /**
   * <p>Describes one or more of your paths.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsPaths">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeNetworkInsightsPathsRequestT = Model::DescribeNetworkInsightsPathsRequest>
  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 <typename DescribeNetworkInsightsPathsRequestT = Model::DescribeNetworkInsightsPathsRequest>
  void DescribeNetworkInsightsPathsAsync(const DescribeNetworkInsightsPathsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeNetworkInsightsPathsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeNetworkInsightsPaths, request, handler, context);
  }

  /**
   * <p>Describes a network interface attribute. You can specify only one attribute
   * at a time.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfaceAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeNetworkInterfaceAttributeRequestT = Model::DescribeNetworkInterfaceAttributeRequest>
  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 <typename DescribeNetworkInterfaceAttributeRequestT = Model::DescribeNetworkInterfaceAttributeRequest>
  void DescribeNetworkInterfaceAttributeAsync(const DescribeNetworkInterfaceAttributeRequestT& request,
                                              const DescribeNetworkInterfaceAttributeResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeNetworkInterfaceAttribute, request, handler, context);
  }

  /**
   * <p>Describes the permissions for your network interfaces. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfacePermissions">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeNetworkInterfacePermissionsRequestT = Model::DescribeNetworkInterfacePermissionsRequest>
  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 <typename DescribeNetworkInterfacePermissionsRequestT = Model::DescribeNetworkInterfacePermissionsRequest>
  void DescribeNetworkInterfacePermissionsAsync(const DescribeNetworkInterfacePermissionsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const DescribeNetworkInterfacePermissionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeNetworkInterfacePermissions, request, handler, context);
  }

  /**
   * <p>Describes the specified network interfaces or all your network
   * interfaces.</p> <p>If you have a large number of network interfaces, the
   * operation fails unless you use pagination or one of the following filters:
   * <code>group-id</code>, <code>mac-address</code>, <code>private-dns-name</code>,
   * <code>private-ip-address</code>, <code>subnet-id</code>, or
   * <code>vpc-id</code>.</p>  <p>We strongly recommend using only
   * paginated requests. Unpaginated requests are susceptible to throttling and
   * timeouts.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfaces">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeNetworkInterfacesRequestT = Model::DescribeNetworkInterfacesRequest>
  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 <typename DescribeNetworkInterfacesRequestT = Model::DescribeNetworkInterfacesRequest>
  void DescribeNetworkInterfacesAsync(const DescribeNetworkInterfacesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeNetworkInterfacesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeNetworkInterfaces, request, handler, context);
  }

  /**
   * <p>Describes the Outposts link aggregation groups (LAGs).</p>  <p>LAGs are
   * only available for second-generation Outposts racks at this time.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeOutpostLags">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeOutpostLagsOutcome DescribeOutpostLags(const Model::DescribeOutpostLagsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeOutpostLags that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeOutpostLagsRequestT = Model::DescribeOutpostLagsRequest>
  Model::DescribeOutpostLagsOutcomeCallable DescribeOutpostLagsCallable(const DescribeOutpostLagsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeOutpostLags, request);
  }

  /**
   * An Async wrapper for DescribeOutpostLags that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename DescribeOutpostLagsRequestT = Model::DescribeOutpostLagsRequest>
  void DescribeOutpostLagsAsync(const DescribeOutpostLagsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeOutpostLagsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeOutpostLags, request, handler, context);
  }

  /**
   * <p>Describes the specified placement groups or all of your placement groups.</p>
   *  <p>To describe a specific placement group that is <i>shared</i> with your
   * account, you must specify the ID of the placement group using the
   * <code>GroupId</code> parameter. Specifying the name of a <i>shared</i> placement
   * group using the <code>GroupNames</code> parameter will result in an error.</p>
   *  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">Placement
   * groups</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePlacementGroups">AWS
   * API Reference</a></p>
   */
  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 <typename DescribePlacementGroupsRequestT = Model::DescribePlacementGroupsRequest>
  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 <typename DescribePlacementGroupsRequestT = Model::DescribePlacementGroupsRequest>
  void DescribePlacementGroupsAsync(const DescribePlacementGroupsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribePlacementGroupsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribePlacementGroups, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePrefixLists">AWS
   * API Reference</a></p>
   */
  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 <typename DescribePrefixListsRequestT = Model::DescribePrefixListsRequest>
  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 <typename DescribePrefixListsRequestT = Model::DescribePrefixListsRequest>
  void DescribePrefixListsAsync(const DescribePrefixListsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribePrefixListsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribePrefixLists, request, handler, context);
  }

  /**
   * <p>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.
   * </p> <p>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.</p> <p>The following resource types support longer IDs:
   * <code>bundle</code> | <code>conversion-task</code> |
   * <code>customer-gateway</code> | <code>dhcp-options</code> |
   * <code>elastic-ip-allocation</code> | <code>elastic-ip-association</code> |
   * <code>export-task</code> | <code>flow-log</code> | <code>image</code> |
   * <code>import-task</code> | <code>instance</code> | <code>internet-gateway</code>
   * | <code>network-acl</code> | <code>network-acl-association</code> |
   * <code>network-interface</code> | <code>network-interface-attachment</code> |
   * <code>prefix-list</code> | <code>reservation</code> | <code>route-table</code> |
   * <code>route-table-association</code> | <code>security-group</code> |
   * <code>snapshot</code> | <code>subnet</code> |
   * <code>subnet-cidr-block-association</code> | <code>volume</code> |
   * <code>vpc</code> | <code>vpc-cidr-block-association</code> |
   * <code>vpc-endpoint</code> | <code>vpc-peering-connection</code> |
   * <code>vpn-connection</code> | <code>vpn-gateway</code>. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePrincipalIdFormat">AWS
   * API Reference</a></p>
   */
  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 <typename DescribePrincipalIdFormatRequestT = Model::DescribePrincipalIdFormatRequest>
  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 <typename DescribePrincipalIdFormatRequestT = Model::DescribePrincipalIdFormatRequest>
  void DescribePrincipalIdFormatAsync(const DescribePrincipalIdFormatResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribePrincipalIdFormatRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribePrincipalIdFormat, request, handler, context);
  }

  /**
   * <p>Describes the specified IPv4 address pools.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePublicIpv4Pools">AWS
   * API Reference</a></p>
   */
  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 <typename DescribePublicIpv4PoolsRequestT = Model::DescribePublicIpv4PoolsRequest>
  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 <typename DescribePublicIpv4PoolsRequestT = Model::DescribePublicIpv4PoolsRequest>
  void DescribePublicIpv4PoolsAsync(const DescribePublicIpv4PoolsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribePublicIpv4PoolsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribePublicIpv4Pools, request, handler, context);
  }

  /**
   * <p>Describes the Regions that are enabled for your account, or all Regions.</p>
   * <p>For a list of the Regions supported by Amazon EC2, see <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/ec2-endpoints.html">Amazon
   * EC2 service endpoints</a>.</p> <p>For information about enabling and disabling
   * Regions for your account, see <a
   * href="https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-regions.html">Specify
   * which Amazon Web Services Regions your account can use</a> in the <i>Amazon Web
   * Services Account Management Reference Guide</i>.</p>  <p>The order of the
   * elements in the response, including those within nested structures, might vary.
   * Applications should not assume the elements appear in a particular order.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRegions">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeRegionsRequestT = Model::DescribeRegionsRequest>
  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 <typename DescribeRegionsRequestT = Model::DescribeRegionsRequest>
  void DescribeRegionsAsync(const DescribeRegionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const DescribeRegionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeRegions, request, handler, context);
  }

  /**
   * <p>Describes a root volume replacement task. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/replace-root.html">Replace
   * a root volume</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReplaceRootVolumeTasks">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeReplaceRootVolumeTasksRequestT = Model::DescribeReplaceRootVolumeTasksRequest>
  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 <typename DescribeReplaceRootVolumeTasksRequestT = Model::DescribeReplaceRootVolumeTasksRequest>
  void DescribeReplaceRootVolumeTasksAsync(const DescribeReplaceRootVolumeTasksResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeReplaceRootVolumeTasksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeReplaceRootVolumeTasks, request, handler, context);
  }

  /**
   * <p>Describes one or more of the Reserved Instances that you purchased.</p>
   * <p>For more information about Reserved Instances, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts-on-demand-reserved-instances.html">Reserved
   * Instances</a> in the <i>Amazon EC2 User Guide</i>.</p>  <p>The order of
   * the elements in the response, including those within nested structures, might
   * vary. Applications should not assume the elements appear in a particular
   * order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstances">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeReservedInstancesRequestT = Model::DescribeReservedInstancesRequest>
  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 <typename DescribeReservedInstancesRequestT = Model::DescribeReservedInstancesRequest>
  void DescribeReservedInstancesAsync(const DescribeReservedInstancesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeReservedInstancesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeReservedInstances, request, handler, context);
  }

  /**
   * <p>Describes your account's Reserved Instance listings in the Reserved Instance
   * Marketplace.</p> <p>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.</p>
   * <p>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.</p> <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Sell
   * in the Reserved Instance Marketplace</a> in the <i>Amazon EC2 User
   * Guide</i>.</p>  <p>The order of the elements in the response, including
   * those within nested structures, might vary. Applications should not assume the
   * elements appear in a particular order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesListings">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeReservedInstancesListingsRequestT = Model::DescribeReservedInstancesListingsRequest>
  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 <typename DescribeReservedInstancesListingsRequestT = Model::DescribeReservedInstancesListingsRequest>
  void DescribeReservedInstancesListingsAsync(const DescribeReservedInstancesListingsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeReservedInstancesListingsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeReservedInstancesListings, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-modifying.html">Modify
   * Reserved Instances</a> in the <i>Amazon EC2 User Guide</i>.</p>  <p>The
   * order of the elements in the response, including those within nested structures,
   * might vary. Applications should not assume the elements appear in a particular
   * order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesModifications">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeReservedInstancesModificationsRequestT = Model::DescribeReservedInstancesModificationsRequest>
  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 <typename DescribeReservedInstancesModificationsRequestT = Model::DescribeReservedInstancesModificationsRequest>
  void DescribeReservedInstancesModificationsAsync(const DescribeReservedInstancesModificationsResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const DescribeReservedInstancesModificationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeReservedInstancesModifications, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Sell
   * in the Reserved Instance Marketplace</a> in the <i>Amazon EC2 User
   * Guide</i>.</p>  <p>The order of the elements in the response, including
   * those within nested structures, might vary. Applications should not assume the
   * elements appear in a particular order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesOfferings">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeReservedInstancesOfferingsRequestT = Model::DescribeReservedInstancesOfferingsRequest>
  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 <typename DescribeReservedInstancesOfferingsRequestT = Model::DescribeReservedInstancesOfferingsRequest>
  void DescribeReservedInstancesOfferingsAsync(const DescribeReservedInstancesOfferingsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeReservedInstancesOfferingsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeReservedInstancesOfferings, request, handler, context);
  }

  /**
   * <p>Describes one or more route server endpoints.</p> <p>A route server endpoint
   * is an Amazon Web Services-managed component inside a subnet that facilitates <a
   * href="https://en.wikipedia.org/wiki/Border_Gateway_Protocol">BGP (Border Gateway
   * Protocol)</a> connections between your route server and your BGP peers.</p>
   * <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRouteServerEndpoints">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeRouteServerEndpointsOutcome DescribeRouteServerEndpoints(
      const Model::DescribeRouteServerEndpointsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeRouteServerEndpoints that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeRouteServerEndpointsRequestT = Model::DescribeRouteServerEndpointsRequest>
  Model::DescribeRouteServerEndpointsOutcomeCallable DescribeRouteServerEndpointsCallable(
      const DescribeRouteServerEndpointsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeRouteServerEndpoints, request);
  }

  /**
   * An Async wrapper for DescribeRouteServerEndpoints that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeRouteServerEndpointsRequestT = Model::DescribeRouteServerEndpointsRequest>
  void DescribeRouteServerEndpointsAsync(const DescribeRouteServerEndpointsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeRouteServerEndpointsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeRouteServerEndpoints, request, handler, context);
  }

  /**
   * <p>Describes one or more route server peers.</p> <p>A route server peer is a
   * session between a route server endpoint and the device deployed in Amazon Web
   * Services (such as a firewall appliance or other network security function
   * running on an EC2 instance). The device must meet these requirements:</p> <ul>
   * <li> <p>Have an elastic network interface in the VPC</p> </li> <li> <p>Support
   * BGP (Border Gateway Protocol)</p> </li> <li> <p>Can initiate BGP sessions</p>
   * </li> </ul> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRouteServerPeers">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeRouteServerPeersOutcome DescribeRouteServerPeers(const Model::DescribeRouteServerPeersRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeRouteServerPeers that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeRouteServerPeersRequestT = Model::DescribeRouteServerPeersRequest>
  Model::DescribeRouteServerPeersOutcomeCallable DescribeRouteServerPeersCallable(
      const DescribeRouteServerPeersRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeRouteServerPeers, request);
  }

  /**
   * An Async wrapper for DescribeRouteServerPeers that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeRouteServerPeersRequestT = Model::DescribeRouteServerPeersRequest>
  void DescribeRouteServerPeersAsync(const DescribeRouteServerPeersResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeRouteServerPeersRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeRouteServerPeers, request, handler, context);
  }

  /**
   * <p>Describes one or more route servers.</p> <p>Amazon VPC Route Server
   * simplifies routing for traffic between workloads that are deployed within a VPC
   * and its internet gateways. With this feature, VPC Route Server dynamically
   * updates VPC and internet gateway route tables with your preferred IPv4 or IPv6
   * routes to achieve routing fault tolerance for those workloads. This enables you
   * to automatically reroute traffic within a VPC, which increases the manageability
   * of VPC routing and interoperability with third-party workloads.</p> <p>Route
   * server supports the follow route table types:</p> <ul> <li> <p>VPC route tables
   * not associated with subnets</p> </li> <li> <p>Subnet route tables</p> </li> <li>
   * <p>Internet gateway route tables</p> </li> </ul> <p>Route server does not
   * support route tables associated with virtual private gateways. To propagate
   * routes into a transit gateway route table, use <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html">Transit
   * Gateway Connect</a>.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRouteServers">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeRouteServersOutcome DescribeRouteServers(const Model::DescribeRouteServersRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeRouteServers that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeRouteServersRequestT = Model::DescribeRouteServersRequest>
  Model::DescribeRouteServersOutcomeCallable DescribeRouteServersCallable(const DescribeRouteServersRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeRouteServers, request);
  }

  /**
   * An Async wrapper for DescribeRouteServers that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeRouteServersRequestT = Model::DescribeRouteServersRequest>
  void DescribeRouteServersAsync(const DescribeRouteServersResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeRouteServersRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeRouteServers, request, handler, context);
  }

  /**
   * <p>Describes your route tables. The default is to describe all your route
   * tables. Alternatively, you can specify specific route table IDs or filter the
   * results to include only the route tables that match specific criteria.</p>
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
   * tables</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRouteTables">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeRouteTablesRequestT = Model::DescribeRouteTablesRequest>
  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 <typename DescribeRouteTablesRequestT = Model::DescribeRouteTablesRequest>
  void DescribeRouteTablesAsync(const DescribeRouteTablesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeRouteTablesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeRouteTables, request, handler, context);
  }

  /**
   * <p>Finds available schedules that meet the specified criteria.</p> <p>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.</p> <p>After you find a schedule that
   * meets your needs, call <a>PurchaseScheduledInstances</a> to purchase Scheduled
   * Instances with that schedule.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeScheduledInstanceAvailability">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeScheduledInstanceAvailabilityRequestT = Model::DescribeScheduledInstanceAvailabilityRequest>
  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 <typename DescribeScheduledInstanceAvailabilityRequestT = Model::DescribeScheduledInstanceAvailabilityRequest>
  void DescribeScheduledInstanceAvailabilityAsync(const DescribeScheduledInstanceAvailabilityRequestT& request,
                                                  const DescribeScheduledInstanceAvailabilityResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeScheduledInstanceAvailability, request, handler, context);
  }

  /**
   * <p>Describes the specified Scheduled Instances or all your Scheduled
   * Instances.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeScheduledInstances">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeScheduledInstancesRequestT = Model::DescribeScheduledInstancesRequest>
  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 <typename DescribeScheduledInstancesRequestT = Model::DescribeScheduledInstancesRequest>
  void DescribeScheduledInstancesAsync(const DescribeScheduledInstancesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeScheduledInstancesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeScheduledInstances, request, handler, context);
  }

  /**
   * <p>Describes one or more of your secondary interfaces.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecondaryInterfaces">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeSecondaryInterfacesOutcome DescribeSecondaryInterfaces(
      const Model::DescribeSecondaryInterfacesRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeSecondaryInterfaces that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeSecondaryInterfacesRequestT = Model::DescribeSecondaryInterfacesRequest>
  Model::DescribeSecondaryInterfacesOutcomeCallable DescribeSecondaryInterfacesCallable(
      const DescribeSecondaryInterfacesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecondaryInterfaces, request);
  }

  /**
   * An Async wrapper for DescribeSecondaryInterfaces that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeSecondaryInterfacesRequestT = Model::DescribeSecondaryInterfacesRequest>
  void DescribeSecondaryInterfacesAsync(const DescribeSecondaryInterfacesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeSecondaryInterfacesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSecondaryInterfaces, request, handler, context);
  }

  /**
   * <p>Describes one or more secondary networks.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecondaryNetworks">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeSecondaryNetworksOutcome DescribeSecondaryNetworks(
      const Model::DescribeSecondaryNetworksRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeSecondaryNetworks that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeSecondaryNetworksRequestT = Model::DescribeSecondaryNetworksRequest>
  Model::DescribeSecondaryNetworksOutcomeCallable DescribeSecondaryNetworksCallable(
      const DescribeSecondaryNetworksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecondaryNetworks, request);
  }

  /**
   * An Async wrapper for DescribeSecondaryNetworks that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeSecondaryNetworksRequestT = Model::DescribeSecondaryNetworksRequest>
  void DescribeSecondaryNetworksAsync(const DescribeSecondaryNetworksResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeSecondaryNetworksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSecondaryNetworks, request, handler, context);
  }

  /**
   * <p>Describes one or more of your secondary subnets.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecondarySubnets">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeSecondarySubnetsOutcome DescribeSecondarySubnets(const Model::DescribeSecondarySubnetsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeSecondarySubnets that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeSecondarySubnetsRequestT = Model::DescribeSecondarySubnetsRequest>
  Model::DescribeSecondarySubnetsOutcomeCallable DescribeSecondarySubnetsCallable(
      const DescribeSecondarySubnetsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecondarySubnets, request);
  }

  /**
   * An Async wrapper for DescribeSecondarySubnets that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeSecondarySubnetsRequestT = Model::DescribeSecondarySubnetsRequest>
  void DescribeSecondarySubnetsAsync(const DescribeSecondarySubnetsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeSecondarySubnetsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSecondarySubnets, request, handler, context);
  }

  /**
   * <p>Describes the VPCs on the other side of a VPC peering or Transit Gateway
   * connection that are referencing the security groups you've specified in this
   * request.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroupReferences">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSecurityGroupReferencesRequestT = Model::DescribeSecurityGroupReferencesRequest>
  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 <typename DescribeSecurityGroupReferencesRequestT = Model::DescribeSecurityGroupReferencesRequest>
  void DescribeSecurityGroupReferencesAsync(const DescribeSecurityGroupReferencesRequestT& request,
                                            const DescribeSecurityGroupReferencesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeSecurityGroupReferences, request, handler, context);
  }

  /**
   * <p>Describes one or more of your security group rules.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroupRules">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSecurityGroupRulesRequestT = Model::DescribeSecurityGroupRulesRequest>
  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 <typename DescribeSecurityGroupRulesRequestT = Model::DescribeSecurityGroupRulesRequest>
  void DescribeSecurityGroupRulesAsync(const DescribeSecurityGroupRulesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeSecurityGroupRulesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSecurityGroupRules, request, handler, context);
  }

  /**
   * <p>Describes security group VPC associations made with <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateSecurityGroupVpc.html">AssociateSecurityGroupVpc</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroupVpcAssociations">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeSecurityGroupVpcAssociationsOutcome DescribeSecurityGroupVpcAssociations(
      const Model::DescribeSecurityGroupVpcAssociationsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeSecurityGroupVpcAssociations that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeSecurityGroupVpcAssociationsRequestT = Model::DescribeSecurityGroupVpcAssociationsRequest>
  Model::DescribeSecurityGroupVpcAssociationsOutcomeCallable DescribeSecurityGroupVpcAssociationsCallable(
      const DescribeSecurityGroupVpcAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecurityGroupVpcAssociations, request);
  }

  /**
   * An Async wrapper for DescribeSecurityGroupVpcAssociations that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeSecurityGroupVpcAssociationsRequestT = Model::DescribeSecurityGroupVpcAssociationsRequest>
  void DescribeSecurityGroupVpcAssociationsAsync(const DescribeSecurityGroupVpcAssociationsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeSecurityGroupVpcAssociationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSecurityGroupVpcAssociations, request, handler, context);
  }

  /**
   * <p>Describes the specified security groups or all of your security
   * groups.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroups">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSecurityGroupsRequestT = Model::DescribeSecurityGroupsRequest>
  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 <typename DescribeSecurityGroupsRequestT = Model::DescribeSecurityGroupsRequest>
  void DescribeSecurityGroupsAsync(const DescribeSecurityGroupsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeSecurityGroupsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSecurityGroups, request, handler, context);
  }

  /**
   * <p>Describes the Outpost service link virtual interfaces.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeServiceLinkVirtualInterfaces">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeServiceLinkVirtualInterfacesOutcome DescribeServiceLinkVirtualInterfaces(
      const Model::DescribeServiceLinkVirtualInterfacesRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeServiceLinkVirtualInterfaces that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeServiceLinkVirtualInterfacesRequestT = Model::DescribeServiceLinkVirtualInterfacesRequest>
  Model::DescribeServiceLinkVirtualInterfacesOutcomeCallable DescribeServiceLinkVirtualInterfacesCallable(
      const DescribeServiceLinkVirtualInterfacesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeServiceLinkVirtualInterfaces, request);
  }

  /**
   * An Async wrapper for DescribeServiceLinkVirtualInterfaces that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeServiceLinkVirtualInterfacesRequestT = Model::DescribeServiceLinkVirtualInterfacesRequest>
  void DescribeServiceLinkVirtualInterfacesAsync(const DescribeServiceLinkVirtualInterfacesResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeServiceLinkVirtualInterfacesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeServiceLinkVirtualInterfaces, request, handler, context);
  }

  /**
   * <p>Describes the specified attribute of the specified snapshot. You can specify
   * only one attribute at a time.</p> <p>For more information about EBS snapshots,
   * see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshots.html">Amazon
   * EBS snapshots</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshotAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSnapshotAttributeRequestT = Model::DescribeSnapshotAttributeRequest>
  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 <typename DescribeSnapshotAttributeRequestT = Model::DescribeSnapshotAttributeRequest>
  void DescribeSnapshotAttributeAsync(const DescribeSnapshotAttributeRequestT& request,
                                      const DescribeSnapshotAttributeResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeSnapshotAttribute, request, handler, context);
  }

  /**
   * <p>Describes the storage tier status of one or more Amazon EBS
   * snapshots.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshotTierStatus">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSnapshotTierStatusRequestT = Model::DescribeSnapshotTierStatusRequest>
  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 <typename DescribeSnapshotTierStatusRequestT = Model::DescribeSnapshotTierStatusRequest>
  void DescribeSnapshotTierStatusAsync(const DescribeSnapshotTierStatusResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeSnapshotTierStatusRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSnapshotTierStatus, request, handler, context);
  }

  /**
   * <p>Describes the specified EBS snapshots available to you or all of the EBS
   * snapshots available to you.</p> <p>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.</p> <p>The create volume permissions fall into the following
   * categories:</p> <ul> <li> <p> <i>public</i>: The owner of the snapshot granted
   * create volume permissions for the snapshot to the <code>all</code> group. All
   * Amazon Web Services accounts have create volume permissions for these
   * snapshots.</p> </li> <li> <p> <i>explicit</i>: The owner of the snapshot granted
   * create volume permissions to a specific Amazon Web Services account.</p> </li>
   * <li> <p> <i>implicit</i>: An Amazon Web Services account has implicit create
   * volume permissions for all snapshots it owns.</p> </li> </ul> <p>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.</p> <p>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.</p> <p>If you specify one or
   * more snapshot owners using the <code>OwnerIds</code> 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,
   * <code>amazon</code> for snapshots owned by Amazon, or <code>self</code> for
   * snapshots that you own.</p> <p>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),
   * <code>self</code> for snapshots for which you own or have explicit permissions,
   * or <code>all</code> for public snapshots.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination">Pagination</a>.</p>
   * <p>For more information about EBS snapshots, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-snapshots.html">Amazon
   * EBS snapshots</a> in the <i>Amazon EBS User Guide</i>.</p>  <p>We
   * strongly recommend using only paginated requests. Unpaginated requests are
   * susceptible to throttling and timeouts.</p> <p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshots">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSnapshotsRequestT = Model::DescribeSnapshotsRequest>
  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 <typename DescribeSnapshotsRequestT = Model::DescribeSnapshotsRequest>
  void DescribeSnapshotsAsync(const DescribeSnapshotsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSnapshots, request, handler, context);
  }

  /**
   * <p>Describes the data feed for Spot Instances. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html">Spot
   * Instance data feed</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotDatafeedSubscription">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSpotDatafeedSubscriptionRequestT = Model::DescribeSpotDatafeedSubscriptionRequest>
  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 <typename DescribeSpotDatafeedSubscriptionRequestT = Model::DescribeSpotDatafeedSubscriptionRequest>
  void DescribeSpotDatafeedSubscriptionAsync(const DescribeSpotDatafeedSubscriptionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DescribeSpotDatafeedSubscriptionRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSpotDatafeedSubscription, request, handler, context);
  }

  /**
   * <p>Describes the running instances for the specified Spot Fleet.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetInstances">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSpotFleetInstancesRequestT = Model::DescribeSpotFleetInstancesRequest>
  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 <typename DescribeSpotFleetInstancesRequestT = Model::DescribeSpotFleetInstancesRequest>
  void DescribeSpotFleetInstancesAsync(const DescribeSpotFleetInstancesRequestT& request,
                                       const DescribeSpotFleetInstancesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeSpotFleetInstances, request, handler, context);
  }

  /**
   * <p>Describes the events for the specified Spot Fleet request during the
   * specified time.</p> <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/fleet-monitor.html">Monitor
   * fleet events using Amazon EventBridge</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetRequestHistory">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSpotFleetRequestHistoryRequestT = Model::DescribeSpotFleetRequestHistoryRequest>
  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 <typename DescribeSpotFleetRequestHistoryRequestT = Model::DescribeSpotFleetRequestHistoryRequest>
  void DescribeSpotFleetRequestHistoryAsync(const DescribeSpotFleetRequestHistoryRequestT& request,
                                            const DescribeSpotFleetRequestHistoryResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeSpotFleetRequestHistory, request, handler, context);
  }

  /**
   * <p>Describes your Spot Fleet requests.</p> <p>Spot Fleet requests are deleted 48
   * hours after they are canceled and their instances are terminated.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetRequests">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSpotFleetRequestsRequestT = Model::DescribeSpotFleetRequestsRequest>
  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 <typename DescribeSpotFleetRequestsRequestT = Model::DescribeSpotFleetRequestsRequest>
  void DescribeSpotFleetRequestsAsync(const DescribeSpotFleetRequestsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeSpotFleetRequestsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSpotFleetRequests, request, handler, context);
  }

  /**
   * <p>Describes the specified Spot Instance requests.</p> <p>You can use
   * <code>DescribeSpotInstanceRequests</code> to find a running Spot Instance by
   * examining the response. If the status of the Spot Instance is
   * <code>fulfilled</code>, the instance ID appears in the response and contains the
   * identifier of the instance. Alternatively, you can use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances">DescribeInstances</a>
   * with a filter to look for instances where the instance lifecycle is
   * <code>spot</code>.</p> <p>We recommend that you set <code>MaxResults</code> 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 <code>MaxResults</code> value, then that
   * number of items is returned along with a <code>NextToken</code> value that can
   * be passed to a subsequent <code>DescribeSpotInstanceRequests</code> request to
   * retrieve the remaining items.</p> <p>Spot Instance requests are deleted four
   * hours after they are canceled and their instances are terminated.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotInstanceRequests">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSpotInstanceRequestsRequestT = Model::DescribeSpotInstanceRequestsRequest>
  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 <typename DescribeSpotInstanceRequestsRequestT = Model::DescribeSpotInstanceRequestsRequest>
  void DescribeSpotInstanceRequestsAsync(const DescribeSpotInstanceRequestsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeSpotInstanceRequestsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSpotInstanceRequests, request, handler, context);
  }

  /**
   * <p>Describes the Spot price history. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html">Spot
   * Instance pricing history</a> in the <i>Amazon EC2 User Guide</i>.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotPriceHistory">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSpotPriceHistoryRequestT = Model::DescribeSpotPriceHistoryRequest>
  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 <typename DescribeSpotPriceHistoryRequestT = Model::DescribeSpotPriceHistoryRequest>
  void DescribeSpotPriceHistoryAsync(const DescribeSpotPriceHistoryResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeSpotPriceHistoryRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSpotPriceHistory, request, handler, context);
  }

  /**
   * <p>Describes the stale security group rules for security groups referenced
   * across a VPC peering connection, transit gateway connection, or with a security
   * group VPC association. Rules are stale when they reference a deleted security
   * group. Rules can also be stale if they reference a security group in a peer VPC
   * for which the VPC peering connection has been deleted, across a transit gateway
   * where the transit gateway has been deleted (or <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-vpc-attachments.html#vpc-attachment-security">the
   * transit gateway security group referencing feature</a> has been disabled), or if
   * a security group VPC association has been disassociated.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeStaleSecurityGroups">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeStaleSecurityGroupsRequestT = Model::DescribeStaleSecurityGroupsRequest>
  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 <typename DescribeStaleSecurityGroupsRequestT = Model::DescribeStaleSecurityGroupsRequest>
  void DescribeStaleSecurityGroupsAsync(const DescribeStaleSecurityGroupsRequestT& request,
                                        const DescribeStaleSecurityGroupsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeStaleSecurityGroups, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For each AMI task, the
   * response indicates if the task is <code>InProgress</code>,
   * <code>Completed</code>, or <code>Failed</code>. For tasks
   * <code>InProgress</code>, the response shows the estimated progress as a
   * percentage.</p> <p>Tasks are listed in reverse chronological order. Currently,
   * only tasks from the past 31 days can be viewed.</p> <p>To use this API, you must
   * have the required permissions. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-ami-store-restore.html#ami-s3-permissions">Permissions
   * for storing and restoring AMIs using S3</a> in the <i>Amazon EC2 User
   * Guide</i>.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html">Store
   * and restore an AMI using S3</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeStoreImageTasks">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeStoreImageTasksRequestT = Model::DescribeStoreImageTasksRequest>
  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 <typename DescribeStoreImageTasksRequestT = Model::DescribeStoreImageTasksRequest>
  void DescribeStoreImageTasksAsync(const DescribeStoreImageTasksResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeStoreImageTasksRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeStoreImageTasks, request, handler, context);
  }

  /**
   * <p>Describes your subnets. The default is to describe all your subnets.
   * Alternatively, you can specify specific subnet IDs or filter the results to
   * include only the subnets that match specific criteria.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/configure-subnets.html">Subnets</a>
   * in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSubnets">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeSubnetsRequestT = Model::DescribeSubnetsRequest>
  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 <typename DescribeSubnetsRequestT = Model::DescribeSubnetsRequest>
  void DescribeSubnetsAsync(const DescribeSubnetsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const DescribeSubnetsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeSubnets, request, handler, context);
  }

  /**
   * <p>Describes the specified tags for your EC2 resources.</p> <p>For more
   * information about tags, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
   * your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User
   * Guide</i>.</p>  <p>We strongly recommend using only paginated
   * requests. Unpaginated requests are susceptible to throttling and timeouts.</p>
   *   <p>The order of the elements in the response, including
   * those within nested structures, might vary. Applications should not assume the
   * elements appear in a particular order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTags">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeTags that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DescribeTagsRequestT = Model::DescribeTagsRequest>
  Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request = {}) const {
    return SubmitCallable(&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 <typename DescribeTagsRequestT = Model::DescribeTagsRequest>
  void DescribeTagsAsync(const DescribeTagsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const DescribeTagsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTags, request, handler, context);
  }

  /**
   * <p>Describe traffic mirror filters that determine the traffic that is
   * mirrored.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorFilterRules">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeTrafficMirrorFilterRulesOutcome DescribeTrafficMirrorFilterRules(
      const Model::DescribeTrafficMirrorFilterRulesRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeTrafficMirrorFilterRules that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DescribeTrafficMirrorFilterRulesRequestT = Model::DescribeTrafficMirrorFilterRulesRequest>
  Model::DescribeTrafficMirrorFilterRulesOutcomeCallable DescribeTrafficMirrorFilterRulesCallable(
      const DescribeTrafficMirrorFilterRulesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTrafficMirrorFilterRules, request);
  }

  /**
   * An Async wrapper for DescribeTrafficMirrorFilterRules that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DescribeTrafficMirrorFilterRulesRequestT = Model::DescribeTrafficMirrorFilterRulesRequest>
  void DescribeTrafficMirrorFilterRulesAsync(const DescribeTrafficMirrorFilterRulesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DescribeTrafficMirrorFilterRulesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTrafficMirrorFilterRules, request, handler, context);
  }

  /**
   * <p>Describes one or more Traffic Mirror filters.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorFilters">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTrafficMirrorFiltersRequestT = Model::DescribeTrafficMirrorFiltersRequest>
  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 <typename DescribeTrafficMirrorFiltersRequestT = Model::DescribeTrafficMirrorFiltersRequest>
  void DescribeTrafficMirrorFiltersAsync(const DescribeTrafficMirrorFiltersResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeTrafficMirrorFiltersRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTrafficMirrorFilters, request, handler, context);
  }

  /**
   * <p>Describes one or more Traffic Mirror sessions. By default, all Traffic Mirror
   * sessions are described. Alternatively, you can filter the results.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorSessions">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTrafficMirrorSessionsRequestT = Model::DescribeTrafficMirrorSessionsRequest>
  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 <typename DescribeTrafficMirrorSessionsRequestT = Model::DescribeTrafficMirrorSessionsRequest>
  void DescribeTrafficMirrorSessionsAsync(const DescribeTrafficMirrorSessionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeTrafficMirrorSessionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTrafficMirrorSessions, request, handler, context);
  }

  /**
   * <p>Information about one or more Traffic Mirror targets.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorTargets">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTrafficMirrorTargetsRequestT = Model::DescribeTrafficMirrorTargetsRequest>
  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 <typename DescribeTrafficMirrorTargetsRequestT = Model::DescribeTrafficMirrorTargetsRequest>
  void DescribeTrafficMirrorTargetsAsync(const DescribeTrafficMirrorTargetsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeTrafficMirrorTargetsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTrafficMirrorTargets, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayAttachments">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewayAttachmentsRequestT = Model::DescribeTransitGatewayAttachmentsRequest>
  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 <typename DescribeTransitGatewayAttachmentsRequestT = Model::DescribeTransitGatewayAttachmentsRequest>
  void DescribeTransitGatewayAttachmentsAsync(const DescribeTransitGatewayAttachmentsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeTransitGatewayAttachmentsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayAttachments, request, handler, context);
  }

  /**
   * <p>Describes one or more Connect peers.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayConnectPeers">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewayConnectPeersRequestT = Model::DescribeTransitGatewayConnectPeersRequest>
  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 <typename DescribeTransitGatewayConnectPeersRequestT = Model::DescribeTransitGatewayConnectPeersRequest>
  void DescribeTransitGatewayConnectPeersAsync(const DescribeTransitGatewayConnectPeersResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeTransitGatewayConnectPeersRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayConnectPeers, request, handler, context);
  }

  /**
   * <p>Describes one or more Connect attachments.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayConnects">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewayConnectsRequestT = Model::DescribeTransitGatewayConnectsRequest>
  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 <typename DescribeTransitGatewayConnectsRequestT = Model::DescribeTransitGatewayConnectsRequest>
  void DescribeTransitGatewayConnectsAsync(const DescribeTransitGatewayConnectsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeTransitGatewayConnectsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayConnects, request, handler, context);
  }

  /**
   * <p>Describes one or more transit gateway metering policies.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayMeteringPolicies">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeTransitGatewayMeteringPoliciesOutcome DescribeTransitGatewayMeteringPolicies(
      const Model::DescribeTransitGatewayMeteringPoliciesRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeTransitGatewayMeteringPolicies that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeTransitGatewayMeteringPoliciesRequestT = Model::DescribeTransitGatewayMeteringPoliciesRequest>
  Model::DescribeTransitGatewayMeteringPoliciesOutcomeCallable DescribeTransitGatewayMeteringPoliciesCallable(
      const DescribeTransitGatewayMeteringPoliciesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayMeteringPolicies, request);
  }

  /**
   * An Async wrapper for DescribeTransitGatewayMeteringPolicies that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeTransitGatewayMeteringPoliciesRequestT = Model::DescribeTransitGatewayMeteringPoliciesRequest>
  void DescribeTransitGatewayMeteringPoliciesAsync(const DescribeTransitGatewayMeteringPoliciesResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const DescribeTransitGatewayMeteringPoliciesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayMeteringPolicies, request, handler, context);
  }

  /**
   * <p>Describes one or more transit gateway multicast domains.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayMulticastDomains">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewayMulticastDomainsRequestT = Model::DescribeTransitGatewayMulticastDomainsRequest>
  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 <typename DescribeTransitGatewayMulticastDomainsRequestT = Model::DescribeTransitGatewayMulticastDomainsRequest>
  void DescribeTransitGatewayMulticastDomainsAsync(const DescribeTransitGatewayMulticastDomainsResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const DescribeTransitGatewayMulticastDomainsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayMulticastDomains, request, handler, context);
  }

  /**
   * <p>Describes your transit gateway peering attachments.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayPeeringAttachments">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewayPeeringAttachmentsRequestT = Model::DescribeTransitGatewayPeeringAttachmentsRequest>
  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 <typename DescribeTransitGatewayPeeringAttachmentsRequestT = Model::DescribeTransitGatewayPeeringAttachmentsRequest>
  void DescribeTransitGatewayPeeringAttachmentsAsync(const DescribeTransitGatewayPeeringAttachmentsResponseReceivedHandler& handler,
                                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                     const DescribeTransitGatewayPeeringAttachmentsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayPeeringAttachments, request, handler, context);
  }

  /**
   * <p>Describes one or more transit gateway route policy tables. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayPolicyTables">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewayPolicyTablesRequestT = Model::DescribeTransitGatewayPolicyTablesRequest>
  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 <typename DescribeTransitGatewayPolicyTablesRequestT = Model::DescribeTransitGatewayPolicyTablesRequest>
  void DescribeTransitGatewayPolicyTablesAsync(const DescribeTransitGatewayPolicyTablesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeTransitGatewayPolicyTablesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayPolicyTables, request, handler, context);
  }

  /**
   * <p>Describes one or more transit gateway route table
   * advertisements.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayRouteTableAnnouncements">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewayRouteTableAnnouncementsRequestT = Model::DescribeTransitGatewayRouteTableAnnouncementsRequest>
  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 <typename DescribeTransitGatewayRouteTableAnnouncementsRequestT = Model::DescribeTransitGatewayRouteTableAnnouncementsRequest>
  void DescribeTransitGatewayRouteTableAnnouncementsAsync(
      const DescribeTransitGatewayRouteTableAnnouncementsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DescribeTransitGatewayRouteTableAnnouncementsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayRouteTableAnnouncements, request, handler, context);
  }

  /**
   * <p>Describes one or more transit gateway route tables. By default, all transit
   * gateway route tables are described. Alternatively, you can filter the
   * results.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayRouteTables">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewayRouteTablesRequestT = Model::DescribeTransitGatewayRouteTablesRequest>
  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 <typename DescribeTransitGatewayRouteTablesRequestT = Model::DescribeTransitGatewayRouteTablesRequest>
  void DescribeTransitGatewayRouteTablesAsync(const DescribeTransitGatewayRouteTablesResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeTransitGatewayRouteTablesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayRouteTables, request, handler, context);
  }

  /**
   * <p>Describes one or more VPC attachments. By default, all VPC attachments are
   * described. Alternatively, you can filter the results.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayVpcAttachments">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewayVpcAttachmentsRequestT = Model::DescribeTransitGatewayVpcAttachmentsRequest>
  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 <typename DescribeTransitGatewayVpcAttachmentsRequestT = Model::DescribeTransitGatewayVpcAttachmentsRequest>
  void DescribeTransitGatewayVpcAttachmentsAsync(const DescribeTransitGatewayVpcAttachmentsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeTransitGatewayVpcAttachmentsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGatewayVpcAttachments, request, handler, context);
  }

  /**
   * <p>Describes one or more transit gateways. By default, all transit gateways are
   * described. Alternatively, you can filter the results.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGateways">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTransitGatewaysRequestT = Model::DescribeTransitGatewaysRequest>
  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 <typename DescribeTransitGatewaysRequestT = Model::DescribeTransitGatewaysRequest>
  void DescribeTransitGatewaysAsync(const DescribeTransitGatewaysResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const DescribeTransitGatewaysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTransitGateways, request, handler, context);
  }

  /**
   * <p>Describes one or more network interface trunk associations.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrunkInterfaceAssociations">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeTrunkInterfaceAssociationsRequestT = Model::DescribeTrunkInterfaceAssociationsRequest>
  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 <typename DescribeTrunkInterfaceAssociationsRequestT = Model::DescribeTrunkInterfaceAssociationsRequest>
  void DescribeTrunkInterfaceAssociationsAsync(const DescribeTrunkInterfaceAssociationsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const DescribeTrunkInterfaceAssociationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeTrunkInterfaceAssociations, request, handler, context);
  }

  /**
   * <p>Describes the specified Amazon Web Services Verified Access
   * endpoints.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessEndpoints">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVerifiedAccessEndpointsRequestT = Model::DescribeVerifiedAccessEndpointsRequest>
  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 <typename DescribeVerifiedAccessEndpointsRequestT = Model::DescribeVerifiedAccessEndpointsRequest>
  void DescribeVerifiedAccessEndpointsAsync(const DescribeVerifiedAccessEndpointsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeVerifiedAccessEndpointsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVerifiedAccessEndpoints, request, handler, context);
  }

  /**
   * <p>Describes the specified Verified Access groups.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessGroups">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVerifiedAccessGroupsRequestT = Model::DescribeVerifiedAccessGroupsRequest>
  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 <typename DescribeVerifiedAccessGroupsRequestT = Model::DescribeVerifiedAccessGroupsRequest>
  void DescribeVerifiedAccessGroupsAsync(const DescribeVerifiedAccessGroupsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeVerifiedAccessGroupsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVerifiedAccessGroups, request, handler, context);
  }

  /**
   * <p>Describes the specified Amazon Web Services Verified Access
   * instances.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessInstanceLoggingConfigurations">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVerifiedAccessInstanceLoggingConfigurationsRequestT =
                Model::DescribeVerifiedAccessInstanceLoggingConfigurationsRequest>
  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 <typename DescribeVerifiedAccessInstanceLoggingConfigurationsRequestT =
                Model::DescribeVerifiedAccessInstanceLoggingConfigurationsRequest>
  void DescribeVerifiedAccessInstanceLoggingConfigurationsAsync(
      const DescribeVerifiedAccessInstanceLoggingConfigurationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DescribeVerifiedAccessInstanceLoggingConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVerifiedAccessInstanceLoggingConfigurations, request, handler, context);
  }

  /**
   * <p>Describes the specified Amazon Web Services Verified Access
   * instances.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessInstances">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVerifiedAccessInstancesRequestT = Model::DescribeVerifiedAccessInstancesRequest>
  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 <typename DescribeVerifiedAccessInstancesRequestT = Model::DescribeVerifiedAccessInstancesRequest>
  void DescribeVerifiedAccessInstancesAsync(const DescribeVerifiedAccessInstancesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeVerifiedAccessInstancesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVerifiedAccessInstances, request, handler, context);
  }

  /**
   * <p>Describes the specified Amazon Web Services Verified Access trust
   * providers.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessTrustProviders">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVerifiedAccessTrustProvidersRequestT = Model::DescribeVerifiedAccessTrustProvidersRequest>
  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 <typename DescribeVerifiedAccessTrustProvidersRequestT = Model::DescribeVerifiedAccessTrustProvidersRequest>
  void DescribeVerifiedAccessTrustProvidersAsync(const DescribeVerifiedAccessTrustProvidersResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeVerifiedAccessTrustProvidersRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVerifiedAccessTrustProviders, request, handler, context);
  }

  /**
   * <p>Describes the specified attribute of the specified volume. You can specify
   * only one attribute at a time.</p> <p>For more information about EBS volumes, see
   * <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-volumes.html">Amazon
   * EBS volumes</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumeAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVolumeAttributeRequestT = Model::DescribeVolumeAttributeRequest>
  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 <typename DescribeVolumeAttributeRequestT = Model::DescribeVolumeAttributeRequest>
  void DescribeVolumeAttributeAsync(const DescribeVolumeAttributeRequestT& request,
                                    const DescribeVolumeAttributeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeVolumeAttribute, request, handler, context);
  }

  /**
   * <p>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.</p> <p>The <code>DescribeVolumeStatus</code>
   * operation provides the following information about the specified volumes:</p>
   * <p> <i>Status</i>: Reflects the current status of the volume. The possible
   * values are <code>ok</code>, <code>impaired</code> , <code>warning</code>, or
   * <code>insufficient-data</code>. If all checks pass, the overall status of the
   * volume is <code>ok</code>. If the check fails, the overall status is
   * <code>impaired</code>. If the status is <code>insufficient-data</code>, 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 <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/monitoring-volume-status.html">Monitor
   * the status of your volumes</a> in the <i>Amazon EBS User Guide</i>.</p> <p>
   * <i>Events</i>: Reflect the cause of a volume status and might require you to
   * take action. For example, if your volume returns an <code>impaired</code>
   * status, then the volume event might be
   * <code>potential-data-inconsistency</code>. 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.</p> <p> <i>Actions</i>: Reflect the actions
   * you might have to take in response to an event. For example, if the status of
   * the volume is <code>impaired</code> and the volume event shows
   * <code>potential-data-inconsistency</code>, then the action shows
   * <code>enable-volume-io</code>. This means that you may want to enable the I/O
   * operations for the volume and then check the volume for data consistency. For
   * more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/work_volumes_impaired.html">Work
   * with an impaired EBS volume</a>.</p> <p>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 <code>error</code> state (for example, when a
   * volume is incapable of accepting I/O.)</p>  <p>The order of the elements
   * in the response, including those within nested structures, might vary.
   * Applications should not assume the elements appear in a particular order.</p>
   * <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumeStatus">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVolumeStatusRequestT = Model::DescribeVolumeStatusRequest>
  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 <typename DescribeVolumeStatusRequestT = Model::DescribeVolumeStatusRequest>
  void DescribeVolumeStatusAsync(const DescribeVolumeStatusResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeVolumeStatusRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVolumeStatus, request, handler, context);
  }

  /**
   * <p>Describes the specified EBS volumes or all of your EBS volumes.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination">Pagination</a>.</p>
   * <p>For more information about EBS volumes, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-volumes.html">Amazon
   * EBS volumes</a> in the <i>Amazon EBS User Guide</i>.</p>  <p>We
   * strongly recommend using only paginated requests. Unpaginated requests are
   * susceptible to throttling and timeouts.</p>   <p>The order of
   * the elements in the response, including those within nested structures, might
   * vary. Applications should not assume the elements appear in a particular
   * order.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumes">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVolumesRequestT = Model::DescribeVolumesRequest>
  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 <typename DescribeVolumesRequestT = Model::DescribeVolumesRequest>
  void DescribeVolumesAsync(const DescribeVolumesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const DescribeVolumesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVolumes, request, handler, context);
  }

  /**
   * <p>Describes the most recent volume modification request for the specified EBS
   * volumes.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/monitoring-volume-modifications.html">
   * Monitor the progress of volume modifications</a> in the <i>Amazon EBS User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumesModifications">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVolumesModificationsRequestT = Model::DescribeVolumesModificationsRequest>
  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 <typename DescribeVolumesModificationsRequestT = Model::DescribeVolumesModificationsRequest>
  void DescribeVolumesModificationsAsync(const DescribeVolumesModificationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DescribeVolumesModificationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVolumesModifications, request, handler, context);
  }

  /**
   * <p>Describes the specified attribute of the specified VPC. You can specify only
   * one attribute at a time.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcAttributeRequestT = Model::DescribeVpcAttributeRequest>
  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 <typename DescribeVpcAttributeRequestT = Model::DescribeVpcAttributeRequest>
  void DescribeVpcAttributeAsync(const DescribeVpcAttributeRequestT& request, const DescribeVpcAttributeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeVpcAttribute, request, handler, context);
  }

  /**
   * <p>Describe VPC Block Public Access (BPA) exclusions. A VPC BPA exclusion is a
   * mode that can be applied to a single VPC or subnet that exempts it from the
   * account’s BPA mode and will allow bidirectional or egress-only access. You can
   * create BPA exclusions for VPCs and subnets even when BPA is not enabled on the
   * account to ensure that there is no traffic disruption to the exclusions when VPC
   * BPA is turned on. To learn more about VPC BPA, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/security-vpc-bpa.html">Block
   * public access to VPCs and subnets</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcBlockPublicAccessExclusions">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeVpcBlockPublicAccessExclusionsOutcome DescribeVpcBlockPublicAccessExclusions(
      const Model::DescribeVpcBlockPublicAccessExclusionsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeVpcBlockPublicAccessExclusions that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeVpcBlockPublicAccessExclusionsRequestT = Model::DescribeVpcBlockPublicAccessExclusionsRequest>
  Model::DescribeVpcBlockPublicAccessExclusionsOutcomeCallable DescribeVpcBlockPublicAccessExclusionsCallable(
      const DescribeVpcBlockPublicAccessExclusionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcBlockPublicAccessExclusions, request);
  }

  /**
   * An Async wrapper for DescribeVpcBlockPublicAccessExclusions that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeVpcBlockPublicAccessExclusionsRequestT = Model::DescribeVpcBlockPublicAccessExclusionsRequest>
  void DescribeVpcBlockPublicAccessExclusionsAsync(const DescribeVpcBlockPublicAccessExclusionsResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const DescribeVpcBlockPublicAccessExclusionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcBlockPublicAccessExclusions, request, handler, context);
  }

  /**
   * <p>Describe VPC Block Public Access (BPA) options. VPC Block Public Access (BPA)
   * enables you to block resources in VPCs and subnets that you own in a Region from
   * reaching or being reached from the internet through internet gateways and
   * egress-only internet gateways. To learn more about VPC BPA, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/security-vpc-bpa.html">Block
   * public access to VPCs and subnets</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcBlockPublicAccessOptions">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeVpcBlockPublicAccessOptionsOutcome DescribeVpcBlockPublicAccessOptions(
      const Model::DescribeVpcBlockPublicAccessOptionsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeVpcBlockPublicAccessOptions that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DescribeVpcBlockPublicAccessOptionsRequestT = Model::DescribeVpcBlockPublicAccessOptionsRequest>
  Model::DescribeVpcBlockPublicAccessOptionsOutcomeCallable DescribeVpcBlockPublicAccessOptionsCallable(
      const DescribeVpcBlockPublicAccessOptionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcBlockPublicAccessOptions, request);
  }

  /**
   * An Async wrapper for DescribeVpcBlockPublicAccessOptions that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DescribeVpcBlockPublicAccessOptionsRequestT = Model::DescribeVpcBlockPublicAccessOptionsRequest>
  void DescribeVpcBlockPublicAccessOptionsAsync(const DescribeVpcBlockPublicAccessOptionsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const DescribeVpcBlockPublicAccessOptionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcBlockPublicAccessOptions, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>Describes the ClassicLink
   * status of the specified VPCs.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcClassicLink">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcClassicLinkRequestT = Model::DescribeVpcClassicLinkRequest>
  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 <typename DescribeVpcClassicLinkRequestT = Model::DescribeVpcClassicLinkRequest>
  void DescribeVpcClassicLinkAsync(const DescribeVpcClassicLinkResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeVpcClassicLinkRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcClassicLink, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcClassicLinkDnsSupport">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcClassicLinkDnsSupportRequestT = Model::DescribeVpcClassicLinkDnsSupportRequest>
  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 <typename DescribeVpcClassicLinkDnsSupportRequestT = Model::DescribeVpcClassicLinkDnsSupportRequest>
  void DescribeVpcClassicLinkDnsSupportAsync(const DescribeVpcClassicLinkDnsSupportResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DescribeVpcClassicLinkDnsSupportRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcClassicLinkDnsSupport, request, handler, context);
  }

  /**
   * <p>Describes one or more VPC Encryption Control configurations. VPC Encryption
   * Control enables you to enforce encryption for all data in transit within and
   * between VPCs to meet compliance requirements You can filter the results to
   * return information about specific encryption controls or VPCs.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html">Enforce
   * VPC encryption in transit</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEncryptionControls">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeVpcEncryptionControlsOutcome DescribeVpcEncryptionControls(
      const Model::DescribeVpcEncryptionControlsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeVpcEncryptionControls that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeVpcEncryptionControlsRequestT = Model::DescribeVpcEncryptionControlsRequest>
  Model::DescribeVpcEncryptionControlsOutcomeCallable DescribeVpcEncryptionControlsCallable(
      const DescribeVpcEncryptionControlsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcEncryptionControls, request);
  }

  /**
   * An Async wrapper for DescribeVpcEncryptionControls that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeVpcEncryptionControlsRequestT = Model::DescribeVpcEncryptionControlsRequest>
  void DescribeVpcEncryptionControlsAsync(const DescribeVpcEncryptionControlsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeVpcEncryptionControlsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcEncryptionControls, request, handler, context);
  }

  /**
   * <p>Describes the VPC resources, VPC endpoint services, Amazon Lattice services,
   * or service networks associated with the VPC endpoint.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointAssociations">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeVpcEndpointAssociationsOutcome DescribeVpcEndpointAssociations(
      const Model::DescribeVpcEndpointAssociationsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeVpcEndpointAssociations that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DescribeVpcEndpointAssociationsRequestT = Model::DescribeVpcEndpointAssociationsRequest>
  Model::DescribeVpcEndpointAssociationsOutcomeCallable DescribeVpcEndpointAssociationsCallable(
      const DescribeVpcEndpointAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcEndpointAssociations, request);
  }

  /**
   * An Async wrapper for DescribeVpcEndpointAssociations that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DescribeVpcEndpointAssociationsRequestT = Model::DescribeVpcEndpointAssociationsRequest>
  void DescribeVpcEndpointAssociationsAsync(const DescribeVpcEndpointAssociationsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DescribeVpcEndpointAssociationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcEndpointAssociations, request, handler, context);
  }

  /**
   * <p>Describes the connection notifications for VPC endpoints and VPC endpoint
   * services.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointConnectionNotifications">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcEndpointConnectionNotificationsRequestT = Model::DescribeVpcEndpointConnectionNotificationsRequest>
  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 <typename DescribeVpcEndpointConnectionNotificationsRequestT = Model::DescribeVpcEndpointConnectionNotificationsRequest>
  void DescribeVpcEndpointConnectionNotificationsAsync(const DescribeVpcEndpointConnectionNotificationsResponseReceivedHandler& handler,
                                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                       const DescribeVpcEndpointConnectionNotificationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcEndpointConnectionNotifications, request, handler, context);
  }

  /**
   * <p>Describes the VPC endpoint connections to your VPC endpoint services,
   * including any endpoints that are pending your acceptance.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointConnections">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcEndpointConnectionsRequestT = Model::DescribeVpcEndpointConnectionsRequest>
  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 <typename DescribeVpcEndpointConnectionsRequestT = Model::DescribeVpcEndpointConnectionsRequest>
  void DescribeVpcEndpointConnectionsAsync(const DescribeVpcEndpointConnectionsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const DescribeVpcEndpointConnectionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcEndpointConnections, request, handler, context);
  }

  /**
   * <p>Describes the VPC endpoint service configurations in your account (your
   * services).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServiceConfigurations">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcEndpointServiceConfigurationsRequestT = Model::DescribeVpcEndpointServiceConfigurationsRequest>
  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 <typename DescribeVpcEndpointServiceConfigurationsRequestT = Model::DescribeVpcEndpointServiceConfigurationsRequest>
  void DescribeVpcEndpointServiceConfigurationsAsync(const DescribeVpcEndpointServiceConfigurationsResponseReceivedHandler& handler,
                                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                     const DescribeVpcEndpointServiceConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcEndpointServiceConfigurations, request, handler, context);
  }

  /**
   * <p>Describes the principals (service consumers) that are permitted to discover
   * your VPC endpoint service. Principal ARNs with path components aren't
   * supported.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServicePermissions">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcEndpointServicePermissionsRequestT = Model::DescribeVpcEndpointServicePermissionsRequest>
  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 <typename DescribeVpcEndpointServicePermissionsRequestT = Model::DescribeVpcEndpointServicePermissionsRequest>
  void DescribeVpcEndpointServicePermissionsAsync(const DescribeVpcEndpointServicePermissionsRequestT& request,
                                                  const DescribeVpcEndpointServicePermissionsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DescribeVpcEndpointServicePermissions, request, handler, context);
  }

  /**
   * <p>Describes available services to which you can create a VPC endpoint.</p>
   * <p>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 <code>us-east-1a</code> and
   * <code>us-east-1c</code> and the consumer uses <code>us-east-1a</code> and
   * <code>us-east-1b</code>, the response includes the VPC endpoint services in the
   * common Availability Zone, <code>us-east-1a</code>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServices">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcEndpointServicesRequestT = Model::DescribeVpcEndpointServicesRequest>
  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 <typename DescribeVpcEndpointServicesRequestT = Model::DescribeVpcEndpointServicesRequest>
  void DescribeVpcEndpointServicesAsync(const DescribeVpcEndpointServicesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeVpcEndpointServicesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcEndpointServices, request, handler, context);
  }

  /**
   * <p>Describes your VPC endpoints. The default is to describe all your VPC
   * endpoints. Alternatively, you can specify specific VPC endpoint IDs or filter
   * the results to include only the VPC endpoints that match specific
   * criteria.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpoints">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcEndpointsRequestT = Model::DescribeVpcEndpointsRequest>
  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 <typename DescribeVpcEndpointsRequestT = Model::DescribeVpcEndpointsRequest>
  void DescribeVpcEndpointsAsync(const DescribeVpcEndpointsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeVpcEndpointsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcEndpoints, request, handler, context);
  }

  /**
   * <p>Describes your VPC peering connections. The default is to describe all your
   * VPC peering connections. Alternatively, you can specify specific VPC peering
   * connection IDs or filter the results to include only the VPC peering connections
   * that match specific criteria.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcPeeringConnections">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcPeeringConnectionsRequestT = Model::DescribeVpcPeeringConnectionsRequest>
  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 <typename DescribeVpcPeeringConnectionsRequestT = Model::DescribeVpcPeeringConnectionsRequest>
  void DescribeVpcPeeringConnectionsAsync(const DescribeVpcPeeringConnectionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeVpcPeeringConnectionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcPeeringConnections, request, handler, context);
  }

  /**
   * <p>Describes your VPCs. The default is to describe all your VPCs. Alternatively,
   * you can specify specific VPC IDs or filter the results to include only the VPCs
   * that match specific criteria.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcs">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpcsRequestT = Model::DescribeVpcsRequest>
  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 <typename DescribeVpcsRequestT = Model::DescribeVpcsRequest>
  void DescribeVpcsAsync(const DescribeVpcsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const DescribeVpcsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpcs, request, handler, context);
  }

  /**
   * <p>Describes one or more of your VPN concentrators.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnConcentrators">AWS
   * API Reference</a></p>
   */
  virtual Model::DescribeVpnConcentratorsOutcome DescribeVpnConcentrators(const Model::DescribeVpnConcentratorsRequest& request = {}) const;

  /**
   * A Callable wrapper for DescribeVpnConcentrators that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DescribeVpnConcentratorsRequestT = Model::DescribeVpnConcentratorsRequest>
  Model::DescribeVpnConcentratorsOutcomeCallable DescribeVpnConcentratorsCallable(
      const DescribeVpnConcentratorsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpnConcentrators, request);
  }

  /**
   * An Async wrapper for DescribeVpnConcentrators that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DescribeVpnConcentratorsRequestT = Model::DescribeVpnConcentratorsRequest>
  void DescribeVpnConcentratorsAsync(const DescribeVpnConcentratorsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeVpnConcentratorsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpnConcentrators, request, handler, context);
  }

  /**
   * <p>Describes one or more of your VPN connections.</p> <p>For more information,
   * see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
   * Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnConnections">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpnConnectionsRequestT = Model::DescribeVpnConnectionsRequest>
  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 <typename DescribeVpnConnectionsRequestT = Model::DescribeVpnConnectionsRequest>
  void DescribeVpnConnectionsAsync(const DescribeVpnConnectionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeVpnConnectionsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpnConnections, request, handler, context);
  }

  /**
   * <p>Describes one or more of your virtual private gateways.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web
   * Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnGateways">AWS
   * API Reference</a></p>
   */
  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 <typename DescribeVpnGatewaysRequestT = Model::DescribeVpnGatewaysRequest>
  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 <typename DescribeVpnGatewaysRequestT = Model::DescribeVpnGatewaysRequest>
  void DescribeVpnGatewaysAsync(const DescribeVpnGatewaysResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DescribeVpnGatewaysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeVpnGateways, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachClassicLinkVpc">AWS
   * API Reference</a></p>
   */
  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 <typename DetachClassicLinkVpcRequestT = Model::DetachClassicLinkVpcRequest>
  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 <typename DetachClassicLinkVpcRequestT = Model::DetachClassicLinkVpcRequest>
  void DetachClassicLinkVpcAsync(const DetachClassicLinkVpcRequestT& request, const DetachClassicLinkVpcResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DetachClassicLinkVpc, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachInternetGateway">AWS
   * API Reference</a></p>
   */
  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 <typename DetachInternetGatewayRequestT = Model::DetachInternetGatewayRequest>
  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 <typename DetachInternetGatewayRequestT = Model::DetachInternetGatewayRequest>
  void DetachInternetGatewayAsync(const DetachInternetGatewayRequestT& request, const DetachInternetGatewayResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DetachInternetGateway, request, handler, context);
  }

  /**
   * <p>Detaches a network interface from an instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachNetworkInterface">AWS
   * API Reference</a></p>
   */
  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 <typename DetachNetworkInterfaceRequestT = Model::DetachNetworkInterfaceRequest>
  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 <typename DetachNetworkInterfaceRequestT = Model::DetachNetworkInterfaceRequest>
  void DetachNetworkInterfaceAsync(const DetachNetworkInterfaceRequestT& request,
                                   const DetachNetworkInterfaceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DetachNetworkInterface, request, handler, context);
  }

  /**
   * <p>Detaches the specified Amazon Web Services Verified Access trust provider
   * from the specified Amazon Web Services Verified Access instance.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVerifiedAccessTrustProvider">AWS
   * API Reference</a></p>
   */
  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 <typename DetachVerifiedAccessTrustProviderRequestT = Model::DetachVerifiedAccessTrustProviderRequest>
  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 <typename DetachVerifiedAccessTrustProviderRequestT = Model::DetachVerifiedAccessTrustProviderRequest>
  void DetachVerifiedAccessTrustProviderAsync(const DetachVerifiedAccessTrustProviderRequestT& request,
                                              const DetachVerifiedAccessTrustProviderResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DetachVerifiedAccessTrustProvider, request, handler, context);
  }

  /**
   * <p>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
   * <code>busy</code> 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.</p> <p>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.</p> <p>You can't detach or force detach volumes
   * that are attached to Amazon Web Services-managed resources. Attempting to do
   * this results in the <code>UnsupportedOperationException</code> exception.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-detaching-volume.html">Detach
   * an Amazon EBS volume</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVolume">AWS
   * API Reference</a></p>
   */
  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 <typename DetachVolumeRequestT = Model::DetachVolumeRequest>
  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 <typename DetachVolumeRequestT = Model::DetachVolumeRequest>
  void DetachVolumeAsync(const DetachVolumeRequestT& request, const DetachVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DetachVolume, request, handler, context);
  }

  /**
   * <p>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).</p> <p>You must wait for the attachment's state to switch to
   * <code>detached</code> before you can delete the VPC or attach a different VPC to
   * the virtual private gateway.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVpnGateway">AWS
   * API Reference</a></p>
   */
  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 <typename DetachVpnGatewayRequestT = Model::DetachVpnGatewayRequest>
  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 <typename DetachVpnGatewayRequestT = Model::DetachVpnGatewayRequest>
  void DetachVpnGatewayAsync(const DetachVpnGatewayRequestT& request, const DetachVpnGatewayResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DetachVpnGateway, request, handler, context);
  }

  /**
   * <p>Disables Elastic IP address transfer. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro">Transfer
   * Elastic IP addresses</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableAddressTransfer">AWS
   * API Reference</a></p>
   */
  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 <typename DisableAddressTransferRequestT = Model::DisableAddressTransferRequest>
  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 <typename DisableAddressTransferRequestT = Model::DisableAddressTransferRequest>
  void DisableAddressTransferAsync(const DisableAddressTransferRequestT& request,
                                   const DisableAddressTransferResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableAddressTransfer, request, handler, context);
  }

  /**
   * <p>Disables Allowed AMIs for your account in the specified Amazon Web Services
   * Region. When set to <code>disabled</code>, the image criteria in your Allowed
   * AMIs settings do not apply, and no restrictions are placed on AMI
   * discoverability or usage. Users in your account can launch instances using any
   * public AMI or AMI shared with your account.</p>  <p>The Allowed AMIs
   * feature does not restrict the AMIs owned by your account. Regardless of the
   * criteria you set, the AMIs created by your account will always be discoverable
   * and usable by users in your account.</p>  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-allowed-amis.html">Control
   * the discovery and use of AMIs in Amazon EC2 with Allowed AMIs</a> in <i>Amazon
   * EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableAllowedImagesSettings">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableAllowedImagesSettingsOutcome DisableAllowedImagesSettings(
      const Model::DisableAllowedImagesSettingsRequest& request = {}) const;

  /**
   * A Callable wrapper for DisableAllowedImagesSettings that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DisableAllowedImagesSettingsRequestT = Model::DisableAllowedImagesSettingsRequest>
  Model::DisableAllowedImagesSettingsOutcomeCallable DisableAllowedImagesSettingsCallable(
      const DisableAllowedImagesSettingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableAllowedImagesSettings, request);
  }

  /**
   * An Async wrapper for DisableAllowedImagesSettings that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DisableAllowedImagesSettingsRequestT = Model::DisableAllowedImagesSettingsRequest>
  void DisableAllowedImagesSettingsAsync(const DisableAllowedImagesSettingsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const DisableAllowedImagesSettingsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DisableAllowedImagesSettings, request, handler, context);
  }

  /**
   * <p>Disables Infrastructure Performance metric subscriptions.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableAwsNetworkPerformanceMetricSubscription">AWS
   * API Reference</a></p>
   */
  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 <typename DisableAwsNetworkPerformanceMetricSubscriptionRequestT = Model::DisableAwsNetworkPerformanceMetricSubscriptionRequest>
  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 <typename DisableAwsNetworkPerformanceMetricSubscriptionRequestT = Model::DisableAwsNetworkPerformanceMetricSubscriptionRequest>
  void DisableAwsNetworkPerformanceMetricSubscriptionAsync(
      const DisableAwsNetworkPerformanceMetricSubscriptionResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DisableAwsNetworkPerformanceMetricSubscriptionRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DisableAwsNetworkPerformanceMetricSubscription, request, handler, context);
  }

  /**
   * <p> Disables EC2 Capacity Manager for your account. This stops data ingestion
   * and removes access to capacity analytics and optimization recommendations.
   * Previously collected data is retained but no new data will be processed.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableCapacityManager">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableCapacityManagerOutcome DisableCapacityManager(const Model::DisableCapacityManagerRequest& request = {}) const;

  /**
   * A Callable wrapper for DisableCapacityManager that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DisableCapacityManagerRequestT = Model::DisableCapacityManagerRequest>
  Model::DisableCapacityManagerOutcomeCallable DisableCapacityManagerCallable(const DisableCapacityManagerRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableCapacityManager, request);
  }

  /**
   * An Async wrapper for DisableCapacityManager that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DisableCapacityManagerRequestT = Model::DisableCapacityManagerRequest>
  void DisableCapacityManagerAsync(const DisableCapacityManagerResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DisableCapacityManagerRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DisableCapacityManager, request, handler, context);
  }

  /**
   * <p>Disables EBS encryption by default for your account in the current
   * Region.</p> <p>After you disable encryption by default, you can still create
   * encrypted volumes by enabling encryption when you create each volume.</p>
   * <p>Disabling encryption by default does not change the encryption status of your
   * existing volumes.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html">Amazon
   * EBS encryption</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableEbsEncryptionByDefault">AWS
   * API Reference</a></p>
   */
  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 <typename DisableEbsEncryptionByDefaultRequestT = Model::DisableEbsEncryptionByDefaultRequest>
  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 <typename DisableEbsEncryptionByDefaultRequestT = Model::DisableEbsEncryptionByDefaultRequest>
  void DisableEbsEncryptionByDefaultAsync(const DisableEbsEncryptionByDefaultResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DisableEbsEncryptionByDefaultRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DisableEbsEncryptionByDefault, request, handler, context);
  }

  /**
   * <p>Discontinue Windows fast launch for a Windows AMI, and clean up existing
   * pre-provisioned snapshots. After you disable Windows fast launch, the AMI uses
   * the standard launch process for each new instance. Amazon EC2 must remove all
   * pre-provisioned snapshots before you can enable Windows fast launch again.</p>
   *  <p>You can only change these settings for Windows AMIs that you own or
   * that have been shared with you.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableFastLaunch">AWS
   * API Reference</a></p>
   */
  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 <typename DisableFastLaunchRequestT = Model::DisableFastLaunchRequest>
  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 <typename DisableFastLaunchRequestT = Model::DisableFastLaunchRequest>
  void DisableFastLaunchAsync(const DisableFastLaunchRequestT& request, const DisableFastLaunchResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableFastLaunch, request, handler, context);
  }

  /**
   * <p>Disables fast snapshot restores for the specified snapshots in the specified
   * Availability Zones.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableFastSnapshotRestores">AWS
   * API Reference</a></p>
   */
  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 <typename DisableFastSnapshotRestoresRequestT = Model::DisableFastSnapshotRestoresRequest>
  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 <typename DisableFastSnapshotRestoresRequestT = Model::DisableFastSnapshotRestoresRequest>
  void DisableFastSnapshotRestoresAsync(const DisableFastSnapshotRestoresRequestT& request,
                                        const DisableFastSnapshotRestoresResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableFastSnapshotRestores, request, handler, context);
  }

  /**
   * <p>Sets the AMI state to <code>disabled</code> and removes all launch
   * permissions from the AMI. A disabled AMI can't be used for instance
   * launches.</p> <p>A disabled AMI can't be shared. If an AMI was public or
   * previously shared, it is made private. If an AMI was shared with an Amazon Web
   * Services account, organization, or Organizational Unit, they lose access to the
   * disabled AMI. </p> <p>A disabled AMI does not appear in <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html">DescribeImages</a>
   * API calls by default.</p> <p>Only the AMI owner can disable an AMI.</p> <p>You
   * can re-enable a disabled AMI using <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EnableImage.html">EnableImage</a>.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/disable-an-ami.html">Disable
   * an AMI</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableImage">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableImageOutcome DisableImage(const Model::DisableImageRequest& request) const;

  /**
   * A Callable wrapper for DisableImage that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename DisableImageRequestT = Model::DisableImageRequest>
  Model::DisableImageOutcomeCallable DisableImageCallable(const DisableImageRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableImage, request);
  }

  /**
   * An Async wrapper for DisableImage that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename DisableImageRequestT = Model::DisableImageRequest>
  void DisableImageAsync(const DisableImageRequestT& request, const DisableImageResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableImage, request, handler, context);
  }

  /**
   * <p>Disables <i>block public access for AMIs</i> at the account level in the
   * specified Amazon Web Services Region. This removes the <i>block public
   * access</i> restriction from your account. With the restriction removed, you can
   * publicly share your AMIs in the specified Amazon Web Services Region.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-to-amis.html">Block
   * public access to your AMIs</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableImageBlockPublicAccess">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableImageBlockPublicAccessOutcome DisableImageBlockPublicAccess(
      const Model::DisableImageBlockPublicAccessRequest& request = {}) const;

  /**
   * A Callable wrapper for DisableImageBlockPublicAccess that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DisableImageBlockPublicAccessRequestT = Model::DisableImageBlockPublicAccessRequest>
  Model::DisableImageBlockPublicAccessOutcomeCallable DisableImageBlockPublicAccessCallable(
      const DisableImageBlockPublicAccessRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableImageBlockPublicAccess, request);
  }

  /**
   * An Async wrapper for DisableImageBlockPublicAccess that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DisableImageBlockPublicAccessRequestT = Model::DisableImageBlockPublicAccessRequest>
  void DisableImageBlockPublicAccessAsync(const DisableImageBlockPublicAccessResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DisableImageBlockPublicAccessRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DisableImageBlockPublicAccess, request, handler, context);
  }

  /**
   * <p>Cancels the deprecation of the specified AMI.</p> <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html">Deprecate
   * an Amazon EC2 AMI</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableImageDeprecation">AWS
   * API Reference</a></p>
   */
  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 <typename DisableImageDeprecationRequestT = Model::DisableImageDeprecationRequest>
  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 <typename DisableImageDeprecationRequestT = Model::DisableImageDeprecationRequest>
  void DisableImageDeprecationAsync(const DisableImageDeprecationRequestT& request,
                                    const DisableImageDeprecationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableImageDeprecation, request, handler, context);
  }

  /**
   * <p>Disables deregistration protection for an AMI. When deregistration protection
   * is disabled, the AMI can be deregistered.</p> <p>If you chose to include a
   * 24-hour cooldown period when you enabled deregistration protection for the AMI,
   * then, when you disable deregistration protection, you won’t immediately be able
   * to deregister the AMI.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deregistration-protection.html">Protect
   * an Amazon EC2 AMI from deregistration</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableImageDeregistrationProtection">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableImageDeregistrationProtectionOutcome DisableImageDeregistrationProtection(
      const Model::DisableImageDeregistrationProtectionRequest& request) const;

  /**
   * A Callable wrapper for DisableImageDeregistrationProtection that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DisableImageDeregistrationProtectionRequestT = Model::DisableImageDeregistrationProtectionRequest>
  Model::DisableImageDeregistrationProtectionOutcomeCallable DisableImageDeregistrationProtectionCallable(
      const DisableImageDeregistrationProtectionRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableImageDeregistrationProtection, request);
  }

  /**
   * An Async wrapper for DisableImageDeregistrationProtection that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DisableImageDeregistrationProtectionRequestT = Model::DisableImageDeregistrationProtectionRequest>
  void DisableImageDeregistrationProtectionAsync(const DisableImageDeregistrationProtectionRequestT& request,
                                                 const DisableImageDeregistrationProtectionResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableImageDeregistrationProtection, request, handler, context);
  }

  /**
   * <p>Disable Amazon EC2 instances running in an SQL Server High Availability
   * cluster from SQL Server High Availability instance standby detection monitoring.
   * Once disabled, Amazon Web Services no longer monitors the metadata for the
   * instances to determine whether they are active or standby nodes in the SQL
   * Server High Availability cluster.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableInstanceSqlHaStandbyDetections">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableInstanceSqlHaStandbyDetectionsOutcome DisableInstanceSqlHaStandbyDetections(
      const Model::DisableInstanceSqlHaStandbyDetectionsRequest& request) const;

  /**
   * A Callable wrapper for DisableInstanceSqlHaStandbyDetections that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DisableInstanceSqlHaStandbyDetectionsRequestT = Model::DisableInstanceSqlHaStandbyDetectionsRequest>
  Model::DisableInstanceSqlHaStandbyDetectionsOutcomeCallable DisableInstanceSqlHaStandbyDetectionsCallable(
      const DisableInstanceSqlHaStandbyDetectionsRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableInstanceSqlHaStandbyDetections, request);
  }

  /**
   * An Async wrapper for DisableInstanceSqlHaStandbyDetections that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DisableInstanceSqlHaStandbyDetectionsRequestT = Model::DisableInstanceSqlHaStandbyDetectionsRequest>
  void DisableInstanceSqlHaStandbyDetectionsAsync(const DisableInstanceSqlHaStandbyDetectionsRequestT& request,
                                                  const DisableInstanceSqlHaStandbyDetectionsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableInstanceSqlHaStandbyDetections, request, handler, context);
  }

  /**
   * <p>Disable the IPAM account. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html">Enable
   * integration with Organizations</a> in the <i>Amazon VPC IPAM User Guide</i>.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableIpamOrganizationAdminAccount">AWS
   * API Reference</a></p>
   */
  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 <typename DisableIpamOrganizationAdminAccountRequestT = Model::DisableIpamOrganizationAdminAccountRequest>
  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 <typename DisableIpamOrganizationAdminAccountRequestT = Model::DisableIpamOrganizationAdminAccountRequest>
  void DisableIpamOrganizationAdminAccountAsync(const DisableIpamOrganizationAdminAccountRequestT& request,
                                                const DisableIpamOrganizationAdminAccountResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableIpamOrganizationAdminAccount, request, handler, context);
  }

  /**
   * <p>Disables an IPAM policy.</p> <p>An IPAM policy is a set of rules that define
   * how public IPv4 addresses from IPAM pools are allocated to Amazon Web Services
   * resources. Each rule maps an Amazon Web Services service to IPAM pools that the
   * service will use to get IP addresses. A single policy can have multiple rules
   * and be applied to multiple Amazon Web Services Regions. If the IPAM pool run out
   * of addresses then the services fallback to Amazon-provided IP addresses. A
   * policy can be applied to an individual Amazon Web Services account or an entity
   * within Amazon Web Services Organizations.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableIpamPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableIpamPolicyOutcome DisableIpamPolicy(const Model::DisableIpamPolicyRequest& request) const;

  /**
   * A Callable wrapper for DisableIpamPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DisableIpamPolicyRequestT = Model::DisableIpamPolicyRequest>
  Model::DisableIpamPolicyOutcomeCallable DisableIpamPolicyCallable(const DisableIpamPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableIpamPolicy, request);
  }

  /**
   * An Async wrapper for DisableIpamPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename DisableIpamPolicyRequestT = Model::DisableIpamPolicyRequest>
  void DisableIpamPolicyAsync(const DisableIpamPolicyRequestT& request, const DisableIpamPolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableIpamPolicy, request, handler, context);
  }

  /**
   * <p>Disables route propagation from a route server to a specified route
   * table.</p> <p>When enabled, route server propagation installs the routes in the
   * FIB on the route table you've specified. Route server supports IPv4 and IPv6
   * route propagation.</p> <p>Amazon VPC Route Server simplifies routing for traffic
   * between workloads that are deployed within a VPC and its internet gateways. With
   * this feature, VPC Route Server dynamically updates VPC and internet gateway
   * route tables with your preferred IPv4 or IPv6 routes to achieve routing fault
   * tolerance for those workloads. This enables you to automatically reroute traffic
   * within a VPC, which increases the manageability of VPC routing and
   * interoperability with third-party workloads.</p> <p>Route server supports the
   * follow route table types:</p> <ul> <li> <p>VPC route tables not associated with
   * subnets</p> </li> <li> <p>Subnet route tables</p> </li> <li> <p>Internet gateway
   * route tables</p> </li> </ul> <p>Route server does not support route tables
   * associated with virtual private gateways. To propagate routes into a transit
   * gateway route table, use <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html">Transit
   * Gateway Connect</a>.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableRouteServerPropagation">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableRouteServerPropagationOutcome DisableRouteServerPropagation(
      const Model::DisableRouteServerPropagationRequest& request) const;

  /**
   * A Callable wrapper for DisableRouteServerPropagation that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DisableRouteServerPropagationRequestT = Model::DisableRouteServerPropagationRequest>
  Model::DisableRouteServerPropagationOutcomeCallable DisableRouteServerPropagationCallable(
      const DisableRouteServerPropagationRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableRouteServerPropagation, request);
  }

  /**
   * An Async wrapper for DisableRouteServerPropagation that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DisableRouteServerPropagationRequestT = Model::DisableRouteServerPropagationRequest>
  void DisableRouteServerPropagationAsync(const DisableRouteServerPropagationRequestT& request,
                                          const DisableRouteServerPropagationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableRouteServerPropagation, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configure-access-to-serial-console.html#serial-console-account-access">Manage
   * account access to the EC2 serial console</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableSerialConsoleAccess">AWS
   * API Reference</a></p>
   */
  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 <typename DisableSerialConsoleAccessRequestT = Model::DisableSerialConsoleAccessRequest>
  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 <typename DisableSerialConsoleAccessRequestT = Model::DisableSerialConsoleAccessRequest>
  void DisableSerialConsoleAccessAsync(const DisableSerialConsoleAccessResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DisableSerialConsoleAccessRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DisableSerialConsoleAccess, request, handler, context);
  }

  /**
   * <p>Disables the <i>block public access for snapshots</i> setting at the account
   * level for the specified Amazon Web Services Region. After you disable block
   * public access for snapshots in a Region, users can publicly share snapshots in
   * that Region.</p>  <p>Enabling block public access for snapshots in
   * <i>block-all-sharing</i> mode does not change the permissions for snapshots that
   * are already publicly shared. Instead, it prevents these snapshots from be
   * publicly visible and publicly accessible. Therefore, the attributes for these
   * snapshots still indicate that they are publicly shared, even though they are not
   * publicly available.</p> <p>If you disable block public access , these snapshots
   * will become publicly available again.</p>  <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/block-public-access-snapshots.html">
   * Block public access for snapshots</a> in the <i>Amazon EBS User Guide</i> .</p>
   * <p/><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableSnapshotBlockPublicAccess">AWS
   * API Reference</a></p>
   */
  virtual Model::DisableSnapshotBlockPublicAccessOutcome DisableSnapshotBlockPublicAccess(
      const Model::DisableSnapshotBlockPublicAccessRequest& request = {}) const;

  /**
   * A Callable wrapper for DisableSnapshotBlockPublicAccess that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename DisableSnapshotBlockPublicAccessRequestT = Model::DisableSnapshotBlockPublicAccessRequest>
  Model::DisableSnapshotBlockPublicAccessOutcomeCallable DisableSnapshotBlockPublicAccessCallable(
      const DisableSnapshotBlockPublicAccessRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableSnapshotBlockPublicAccess, request);
  }

  /**
   * An Async wrapper for DisableSnapshotBlockPublicAccess that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename DisableSnapshotBlockPublicAccessRequestT = Model::DisableSnapshotBlockPublicAccessRequest>
  void DisableSnapshotBlockPublicAccessAsync(const DisableSnapshotBlockPublicAccessResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DisableSnapshotBlockPublicAccessRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DisableSnapshotBlockPublicAccess, request, handler, context);
  }

  /**
   * <p>Disables the specified resource attachment from propagating routes to the
   * specified propagation route table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableTransitGatewayRouteTablePropagation">AWS
   * API Reference</a></p>
   */
  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 <typename DisableTransitGatewayRouteTablePropagationRequestT = Model::DisableTransitGatewayRouteTablePropagationRequest>
  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 <typename DisableTransitGatewayRouteTablePropagationRequestT = Model::DisableTransitGatewayRouteTablePropagationRequest>
  void DisableTransitGatewayRouteTablePropagationAsync(
      const DisableTransitGatewayRouteTablePropagationRequestT& request,
      const DisableTransitGatewayRouteTablePropagationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableTransitGatewayRouteTablePropagation, request, handler, context);
  }

  /**
   * <p>Disables a virtual private gateway (VGW) from propagating routes to a
   * specified route table of a VPC.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVgwRoutePropagation">AWS
   * API Reference</a></p>
   */
  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 <typename DisableVgwRoutePropagationRequestT = Model::DisableVgwRoutePropagationRequest>
  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 <typename DisableVgwRoutePropagationRequestT = Model::DisableVgwRoutePropagationRequest>
  void DisableVgwRoutePropagationAsync(const DisableVgwRoutePropagationRequestT& request,
                                       const DisableVgwRoutePropagationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableVgwRoutePropagation, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>Disables ClassicLink for a
   * VPC. You cannot disable ClassicLink for a VPC that has EC2-Classic instances
   * linked to it.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVpcClassicLink">AWS
   * API Reference</a></p>
   */
  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 <typename DisableVpcClassicLinkRequestT = Model::DisableVpcClassicLinkRequest>
  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 <typename DisableVpcClassicLinkRequestT = Model::DisableVpcClassicLinkRequest>
  void DisableVpcClassicLinkAsync(const DisableVpcClassicLinkRequestT& request, const DisableVpcClassicLinkResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisableVpcClassicLink, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>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.</p> <p>You must specify a VPC ID in the
   * request.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVpcClassicLinkDnsSupport">AWS
   * API Reference</a></p>
   */
  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 <typename DisableVpcClassicLinkDnsSupportRequestT = Model::DisableVpcClassicLinkDnsSupportRequest>
  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 <typename DisableVpcClassicLinkDnsSupportRequestT = Model::DisableVpcClassicLinkDnsSupportRequest>
  void DisableVpcClassicLinkDnsSupportAsync(const DisableVpcClassicLinkDnsSupportResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const DisableVpcClassicLinkDnsSupportRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DisableVpcClassicLinkDnsSupport, request, handler, context);
  }

  /**
   * <p>Disassociates an Elastic IP address from the instance or network interface
   * it's associated with.</p> <p>This is an idempotent operation. If you perform the
   * operation more than once, Amazon EC2 doesn't return an error.</p> <p>An address
   * cannot be disassociated if the all of the following conditions are met:</p> <ul>
   * <li> <p>Network interface has a <code>publicDualStackDnsName</code>
   * publicDnsName</p> </li> <li> <p>Public IPv4 address is the primary public IPv4
   * address</p> </li> <li> <p>Network interface only has one remaining public IPv4
   * address</p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateAddress">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateAddressRequestT = Model::DisassociateAddressRequest>
  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 <typename DisassociateAddressRequestT = Model::DisassociateAddressRequest>
  void DisassociateAddressAsync(const DisassociateAddressResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const DisassociateAddressRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DisassociateAddress, request, handler, context);
  }

  /**
   * <p>Cancels a pending request to assign billing of the unused capacity of a
   * Capacity Reservation to a consumer account, or revokes a request that has
   * already been accepted. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/assign-billing.html">Billing
   * assignment for shared Amazon EC2 Capacity Reservations</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateCapacityReservationBillingOwner">AWS
   * API Reference</a></p>
   */
  virtual Model::DisassociateCapacityReservationBillingOwnerOutcome DisassociateCapacityReservationBillingOwner(
      const Model::DisassociateCapacityReservationBillingOwnerRequest& request) const;

  /**
   * A Callable wrapper for DisassociateCapacityReservationBillingOwner that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename DisassociateCapacityReservationBillingOwnerRequestT = Model::DisassociateCapacityReservationBillingOwnerRequest>
  Model::DisassociateCapacityReservationBillingOwnerOutcomeCallable DisassociateCapacityReservationBillingOwnerCallable(
      const DisassociateCapacityReservationBillingOwnerRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateCapacityReservationBillingOwner, request);
  }

  /**
   * An Async wrapper for DisassociateCapacityReservationBillingOwner that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename DisassociateCapacityReservationBillingOwnerRequestT = Model::DisassociateCapacityReservationBillingOwnerRequest>
  void DisassociateCapacityReservationBillingOwnerAsync(
      const DisassociateCapacityReservationBillingOwnerRequestT& request,
      const DisassociateCapacityReservationBillingOwnerResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateCapacityReservationBillingOwner, request, handler, context);
  }

  /**
   * <p>Disassociates a target network from the specified Client VPN endpoint. When
   * you disassociate the last target network from a Client VPN, the following
   * happens:</p> <ul> <li> <p>The route that was automatically added for the VPC is
   * deleted</p> </li> <li> <p>All active client connections are terminated</p> </li>
   * <li> <p>New client connections are disallowed</p> </li> <li> <p>The Client VPN
   * endpoint's status changes to <code>pending-associate</code> </p> </li>
   * </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateClientVpnTargetNetwork">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateClientVpnTargetNetworkRequestT = Model::DisassociateClientVpnTargetNetworkRequest>
  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 <typename DisassociateClientVpnTargetNetworkRequestT = Model::DisassociateClientVpnTargetNetworkRequest>
  void DisassociateClientVpnTargetNetworkAsync(const DisassociateClientVpnTargetNetworkRequestT& request,
                                               const DisassociateClientVpnTargetNetworkResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateClientVpnTargetNetwork, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateEnclaveCertificateIamRole">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateEnclaveCertificateIamRoleRequestT = Model::DisassociateEnclaveCertificateIamRoleRequest>
  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 <typename DisassociateEnclaveCertificateIamRoleRequestT = Model::DisassociateEnclaveCertificateIamRoleRequest>
  void DisassociateEnclaveCertificateIamRoleAsync(const DisassociateEnclaveCertificateIamRoleRequestT& request,
                                                  const DisassociateEnclaveCertificateIamRoleResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateEnclaveCertificateIamRole, request, handler, context);
  }

  /**
   * <p>Disassociates an IAM instance profile from a running or stopped instance.</p>
   * <p>Use <a>DescribeIamInstanceProfileAssociations</a> to get the association
   * ID.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateIamInstanceProfile">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateIamInstanceProfileRequestT = Model::DisassociateIamInstanceProfileRequest>
  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 <typename DisassociateIamInstanceProfileRequestT = Model::DisassociateIamInstanceProfileRequest>
  void DisassociateIamInstanceProfileAsync(const DisassociateIamInstanceProfileRequestT& request,
                                           const DisassociateIamInstanceProfileResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateIamInstanceProfile, request, handler, context);
  }

  /**
   * <p>Disassociates one or more targets from an event window.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
   * event windows for scheduled events</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateInstanceEventWindow">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateInstanceEventWindowRequestT = Model::DisassociateInstanceEventWindowRequest>
  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 <typename DisassociateInstanceEventWindowRequestT = Model::DisassociateInstanceEventWindowRequest>
  void DisassociateInstanceEventWindowAsync(const DisassociateInstanceEventWindowRequestT& request,
                                            const DisassociateInstanceEventWindowResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateInstanceEventWindow, request, handler, context);
  }

  /**
   * <p>Remove the association between your Autonomous System Number (ASN) and your
   * BYOIP CIDR. You may want to use this action to disassociate an ASN from a CIDR
   * or if you want to swap ASNs. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoasn.html">Tutorial:
   * Bring your ASN to IPAM</a> in the <i>Amazon VPC IPAM guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateIpamByoasn">AWS
   * API Reference</a></p>
   */
  virtual Model::DisassociateIpamByoasnOutcome DisassociateIpamByoasn(const Model::DisassociateIpamByoasnRequest& request) const;

  /**
   * A Callable wrapper for DisassociateIpamByoasn that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DisassociateIpamByoasnRequestT = Model::DisassociateIpamByoasnRequest>
  Model::DisassociateIpamByoasnOutcomeCallable DisassociateIpamByoasnCallable(const DisassociateIpamByoasnRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateIpamByoasn, request);
  }

  /**
   * An Async wrapper for DisassociateIpamByoasn that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DisassociateIpamByoasnRequestT = Model::DisassociateIpamByoasnRequest>
  void DisassociateIpamByoasnAsync(const DisassociateIpamByoasnRequestT& request,
                                   const DisassociateIpamByoasnResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateIpamByoasn, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateIpamResourceDiscovery">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateIpamResourceDiscoveryRequestT = Model::DisassociateIpamResourceDiscoveryRequest>
  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 <typename DisassociateIpamResourceDiscoveryRequestT = Model::DisassociateIpamResourceDiscoveryRequest>
  void DisassociateIpamResourceDiscoveryAsync(const DisassociateIpamResourceDiscoveryRequestT& request,
                                              const DisassociateIpamResourceDiscoveryResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateIpamResourceDiscovery, request, handler, context);
  }

  /**
   * <p>Disassociates secondary Elastic IP addresses (EIPs) from a public NAT
   * gateway. You cannot disassociate your primary EIP. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-working-with.html#nat-gateway-edit-secondary">Edit
   * secondary IP address associations</a> in the <i>Amazon VPC User Guide</i>.</p>
   * <p>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.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateNatGatewayAddress">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateNatGatewayAddressRequestT = Model::DisassociateNatGatewayAddressRequest>
  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 <typename DisassociateNatGatewayAddressRequestT = Model::DisassociateNatGatewayAddressRequest>
  void DisassociateNatGatewayAddressAsync(const DisassociateNatGatewayAddressRequestT& request,
                                          const DisassociateNatGatewayAddressResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateNatGatewayAddress, request, handler, context);
  }

  /**
   * <p>Disassociates a route server from a VPC.</p> <p>A route server association is
   * the connection established between a route server and a VPC.</p> <p>For more
   * information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateRouteServer">AWS
   * API Reference</a></p>
   */
  virtual Model::DisassociateRouteServerOutcome DisassociateRouteServer(const Model::DisassociateRouteServerRequest& request) const;

  /**
   * A Callable wrapper for DisassociateRouteServer that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename DisassociateRouteServerRequestT = Model::DisassociateRouteServerRequest>
  Model::DisassociateRouteServerOutcomeCallable DisassociateRouteServerCallable(const DisassociateRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateRouteServer, request);
  }

  /**
   * An Async wrapper for DisassociateRouteServer that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DisassociateRouteServerRequestT = Model::DisassociateRouteServerRequest>
  void DisassociateRouteServerAsync(const DisassociateRouteServerRequestT& request,
                                    const DisassociateRouteServerResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateRouteServer, request, handler, context);
  }

  /**
   * <p>Disassociates a subnet or gateway from a route table.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
   * tables</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateRouteTableRequestT = Model::DisassociateRouteTableRequest>
  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 <typename DisassociateRouteTableRequestT = Model::DisassociateRouteTableRequest>
  void DisassociateRouteTableAsync(const DisassociateRouteTableRequestT& request,
                                   const DisassociateRouteTableResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateRouteTable, request, handler, context);
  }

  /**
   * <p>Disassociates a security group from a VPC. You cannot disassociate the
   * security group if any Elastic network interfaces in the associated VPC are still
   * associated with the security group. Note that the disassociation is asynchronous
   * and you can check the status of the request with <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroupVpcAssociations.html">DescribeSecurityGroupVpcAssociations</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateSecurityGroupVpc">AWS
   * API Reference</a></p>
   */
  virtual Model::DisassociateSecurityGroupVpcOutcome DisassociateSecurityGroupVpc(
      const Model::DisassociateSecurityGroupVpcRequest& request) const;

  /**
   * A Callable wrapper for DisassociateSecurityGroupVpc that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename DisassociateSecurityGroupVpcRequestT = Model::DisassociateSecurityGroupVpcRequest>
  Model::DisassociateSecurityGroupVpcOutcomeCallable DisassociateSecurityGroupVpcCallable(
      const DisassociateSecurityGroupVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateSecurityGroupVpc, request);
  }

  /**
   * An Async wrapper for DisassociateSecurityGroupVpc that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename DisassociateSecurityGroupVpcRequestT = Model::DisassociateSecurityGroupVpcRequest>
  void DisassociateSecurityGroupVpcAsync(const DisassociateSecurityGroupVpcRequestT& request,
                                         const DisassociateSecurityGroupVpcResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateSecurityGroupVpc, request, handler, context);
  }

  /**
   * <p>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.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateSubnetCidrBlock">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateSubnetCidrBlockRequestT = Model::DisassociateSubnetCidrBlockRequest>
  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 <typename DisassociateSubnetCidrBlockRequestT = Model::DisassociateSubnetCidrBlockRequest>
  void DisassociateSubnetCidrBlockAsync(const DisassociateSubnetCidrBlockRequestT& request,
                                        const DisassociateSubnetCidrBlockResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateSubnetCidrBlock, request, handler, context);
  }

  /**
   * <p>Disassociates the specified subnets from the transit gateway multicast
   * domain. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayMulticastDomain">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateTransitGatewayMulticastDomainRequestT = Model::DisassociateTransitGatewayMulticastDomainRequest>
  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 <typename DisassociateTransitGatewayMulticastDomainRequestT = Model::DisassociateTransitGatewayMulticastDomainRequest>
  void DisassociateTransitGatewayMulticastDomainAsync(
      const DisassociateTransitGatewayMulticastDomainRequestT& request,
      const DisassociateTransitGatewayMulticastDomainResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateTransitGatewayMulticastDomain, request, handler, context);
  }

  /**
   * <p>Removes the association between an an attachment and a policy
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayPolicyTable">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateTransitGatewayPolicyTableRequestT = Model::DisassociateTransitGatewayPolicyTableRequest>
  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 <typename DisassociateTransitGatewayPolicyTableRequestT = Model::DisassociateTransitGatewayPolicyTableRequest>
  void DisassociateTransitGatewayPolicyTableAsync(const DisassociateTransitGatewayPolicyTableRequestT& request,
                                                  const DisassociateTransitGatewayPolicyTableResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateTransitGatewayPolicyTable, request, handler, context);
  }

  /**
   * <p>Disassociates a resource attachment from a transit gateway route
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayRouteTable">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateTransitGatewayRouteTableRequestT = Model::DisassociateTransitGatewayRouteTableRequest>
  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 <typename DisassociateTransitGatewayRouteTableRequestT = Model::DisassociateTransitGatewayRouteTableRequest>
  void DisassociateTransitGatewayRouteTableAsync(const DisassociateTransitGatewayRouteTableRequestT& request,
                                                 const DisassociateTransitGatewayRouteTableResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateTransitGatewayRouteTable, request, handler, context);
  }

  /**
   * <p>Removes an association between a branch network interface with a trunk
   * network interface.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTrunkInterface">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateTrunkInterfaceRequestT = Model::DisassociateTrunkInterfaceRequest>
  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 <typename DisassociateTrunkInterfaceRequestT = Model::DisassociateTrunkInterfaceRequest>
  void DisassociateTrunkInterfaceAsync(const DisassociateTrunkInterfaceRequestT& request,
                                       const DisassociateTrunkInterfaceResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateTrunkInterface, request, handler, context);
  }

  /**
   * <p>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
   * <a>DescribeVpcs</a>. You must detach or delete all gateways and resources that
   * are associated with the CIDR block before you can disassociate it. </p> <p>You
   * cannot disassociate the CIDR block with which you originally created the VPC
   * (the primary CIDR block).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateVpcCidrBlock">AWS
   * API Reference</a></p>
   */
  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 <typename DisassociateVpcCidrBlockRequestT = Model::DisassociateVpcCidrBlockRequest>
  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 <typename DisassociateVpcCidrBlockRequestT = Model::DisassociateVpcCidrBlockRequest>
  void DisassociateVpcCidrBlockAsync(const DisassociateVpcCidrBlockRequestT& request,
                                     const DisassociateVpcCidrBlockResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DisassociateVpcCidrBlock, request, handler, context);
  }

  /**
   * <p>Enables Elastic IP address transfer. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro">Transfer
   * Elastic IP addresses</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableAddressTransfer">AWS
   * API Reference</a></p>
   */
  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 <typename EnableAddressTransferRequestT = Model::EnableAddressTransferRequest>
  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 <typename EnableAddressTransferRequestT = Model::EnableAddressTransferRequest>
  void EnableAddressTransferAsync(const EnableAddressTransferRequestT& request, const EnableAddressTransferResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableAddressTransfer, request, handler, context);
  }

  /**
   * <p>Enables Allowed AMIs for your account in the specified Amazon Web Services
   * Region. Two values are accepted:</p> <ul> <li> <p> <code>enabled</code>: The
   * image criteria in your Allowed AMIs settings are applied. As a result, only AMIs
   * matching these criteria are discoverable and can be used by your account to
   * launch instances.</p> </li> <li> <p> <code>audit-mode</code>: The image criteria
   * in your Allowed AMIs settings are not applied. No restrictions are placed on AMI
   * discoverability or usage. Users in your account can launch instances using any
   * public AMI or AMI shared with your account.</p> <p>The purpose of
   * <code>audit-mode</code> is to indicate which AMIs will be affected when Allowed
   * AMIs is <code>enabled</code>. In <code>audit-mode</code>, each AMI displays
   * either <code>"ImageAllowed": true</code> or <code>"ImageAllowed": false</code>
   * to indicate whether the AMI will be discoverable and available to users in the
   * account when Allowed AMIs is enabled.</p> </li> </ul>  <p>The Allowed AMIs
   * feature does not restrict the AMIs owned by your account. Regardless of the
   * criteria you set, the AMIs created by your account will always be discoverable
   * and usable by users in your account.</p>  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-allowed-amis.html">Control
   * the discovery and use of AMIs in Amazon EC2 with Allowed AMIs</a> in <i>Amazon
   * EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableAllowedImagesSettings">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableAllowedImagesSettingsOutcome EnableAllowedImagesSettings(
      const Model::EnableAllowedImagesSettingsRequest& request) const;

  /**
   * A Callable wrapper for EnableAllowedImagesSettings that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename EnableAllowedImagesSettingsRequestT = Model::EnableAllowedImagesSettingsRequest>
  Model::EnableAllowedImagesSettingsOutcomeCallable EnableAllowedImagesSettingsCallable(
      const EnableAllowedImagesSettingsRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableAllowedImagesSettings, request);
  }

  /**
   * An Async wrapper for EnableAllowedImagesSettings that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename EnableAllowedImagesSettingsRequestT = Model::EnableAllowedImagesSettingsRequest>
  void EnableAllowedImagesSettingsAsync(const EnableAllowedImagesSettingsRequestT& request,
                                        const EnableAllowedImagesSettingsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableAllowedImagesSettings, request, handler, context);
  }

  /**
   * <p>Enables Infrastructure Performance subscriptions.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableAwsNetworkPerformanceMetricSubscription">AWS
   * API Reference</a></p>
   */
  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 <typename EnableAwsNetworkPerformanceMetricSubscriptionRequestT = Model::EnableAwsNetworkPerformanceMetricSubscriptionRequest>
  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 <typename EnableAwsNetworkPerformanceMetricSubscriptionRequestT = Model::EnableAwsNetworkPerformanceMetricSubscriptionRequest>
  void EnableAwsNetworkPerformanceMetricSubscriptionAsync(
      const EnableAwsNetworkPerformanceMetricSubscriptionResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const EnableAwsNetworkPerformanceMetricSubscriptionRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::EnableAwsNetworkPerformanceMetricSubscription, request, handler, context);
  }

  /**
   * <p> Enables EC2 Capacity Manager for your account. This starts data ingestion
   * for your EC2 capacity usage across On-Demand, Spot, and Capacity Reservations.
   * Initial data processing may take several hours to complete. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableCapacityManager">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableCapacityManagerOutcome EnableCapacityManager(const Model::EnableCapacityManagerRequest& request = {}) const;

  /**
   * A Callable wrapper for EnableCapacityManager that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename EnableCapacityManagerRequestT = Model::EnableCapacityManagerRequest>
  Model::EnableCapacityManagerOutcomeCallable EnableCapacityManagerCallable(const EnableCapacityManagerRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::EnableCapacityManager, request);
  }

  /**
   * An Async wrapper for EnableCapacityManager that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename EnableCapacityManagerRequestT = Model::EnableCapacityManagerRequest>
  void EnableCapacityManagerAsync(const EnableCapacityManagerResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const EnableCapacityManagerRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::EnableCapacityManager, request, handler, context);
  }

  /**
   * <p>Enables EBS encryption by default for your account in the current Region.</p>
   * <p>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 <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html">Amazon
   * EBS encryption</a> in the <i>Amazon EBS User Guide</i>.</p> <p>Enabling
   * encryption by default has no effect on the encryption status of your existing
   * volumes.</p> <p>After you enable encryption by default, you can no longer launch
   * instances using instance types that do not support encryption. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption-requirements.html#ebs-encryption_supported_instances">Supported
   * instance types</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableEbsEncryptionByDefault">AWS
   * API Reference</a></p>
   */
  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 <typename EnableEbsEncryptionByDefaultRequestT = Model::EnableEbsEncryptionByDefaultRequest>
  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 <typename EnableEbsEncryptionByDefaultRequestT = Model::EnableEbsEncryptionByDefaultRequest>
  void EnableEbsEncryptionByDefaultAsync(const EnableEbsEncryptionByDefaultResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const EnableEbsEncryptionByDefaultRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::EnableEbsEncryptionByDefault, request, handler, context);
  }

  /**
   * <p>When you enable Windows fast launch 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.</p>  <p>You can only change these settings for Windows
   * AMIs that you own or that have been shared with you.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableFastLaunch">AWS
   * API Reference</a></p>
   */
  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 <typename EnableFastLaunchRequestT = Model::EnableFastLaunchRequest>
  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 <typename EnableFastLaunchRequestT = Model::EnableFastLaunchRequest>
  void EnableFastLaunchAsync(const EnableFastLaunchRequestT& request, const EnableFastLaunchResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableFastLaunch, request, handler, context);
  }

  /**
   * <p>Enables fast snapshot restores for the specified snapshots in the specified
   * Availability Zones.</p> <p>You get the full benefit of fast snapshot restores
   * after they enter the <code>enabled</code> state.</p> <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-fast-snapshot-restore.html">Amazon
   * EBS fast snapshot restore</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableFastSnapshotRestores">AWS
   * API Reference</a></p>
   */
  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 <typename EnableFastSnapshotRestoresRequestT = Model::EnableFastSnapshotRestoresRequest>
  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 <typename EnableFastSnapshotRestoresRequestT = Model::EnableFastSnapshotRestoresRequest>
  void EnableFastSnapshotRestoresAsync(const EnableFastSnapshotRestoresRequestT& request,
                                       const EnableFastSnapshotRestoresResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableFastSnapshotRestores, request, handler, context);
  }

  /**
   * <p>Re-enables a disabled AMI. The re-enabled AMI is marked as
   * <code>available</code> and can be used for instance launches, appears in
   * describe operations, and can be shared. Amazon Web Services accounts,
   * organizations, and Organizational Units that lost access to the AMI when it was
   * disabled do not regain access automatically. Once the AMI is available, it can
   * be shared with them again.</p> <p>Only the AMI owner can re-enable a disabled
   * AMI.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/disable-an-ami.html">Disable
   * an Amazon EC2 AMI</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableImage">AWS API
   * Reference</a></p>
   */
  virtual Model::EnableImageOutcome EnableImage(const Model::EnableImageRequest& request) const;

  /**
   * A Callable wrapper for EnableImage that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename EnableImageRequestT = Model::EnableImageRequest>
  Model::EnableImageOutcomeCallable EnableImageCallable(const EnableImageRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableImage, request);
  }

  /**
   * An Async wrapper for EnableImage that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename EnableImageRequestT = Model::EnableImageRequest>
  void EnableImageAsync(const EnableImageRequestT& request, const EnableImageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableImage, request, handler, context);
  }

  /**
   * <p>Enables <i>block public access for AMIs</i> at the account level in the
   * specified Amazon Web Services Region. This prevents the public sharing of your
   * AMIs. However, if you already have public AMIs, they will remain publicly
   * available.</p> <p>The API can take up to 10 minutes to configure this setting.
   * During this time, if you run <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetImageBlockPublicAccessState.html">GetImageBlockPublicAccessState</a>,
   * the response will be <code>unblocked</code>. When the API has completed the
   * configuration, the response will be <code>block-new-sharing</code>.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-to-amis.html">Block
   * public access to your AMIs</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableImageBlockPublicAccess">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableImageBlockPublicAccessOutcome EnableImageBlockPublicAccess(
      const Model::EnableImageBlockPublicAccessRequest& request) const;

  /**
   * A Callable wrapper for EnableImageBlockPublicAccess that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename EnableImageBlockPublicAccessRequestT = Model::EnableImageBlockPublicAccessRequest>
  Model::EnableImageBlockPublicAccessOutcomeCallable EnableImageBlockPublicAccessCallable(
      const EnableImageBlockPublicAccessRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableImageBlockPublicAccess, request);
  }

  /**
   * An Async wrapper for EnableImageBlockPublicAccess that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename EnableImageBlockPublicAccessRequestT = Model::EnableImageBlockPublicAccessRequest>
  void EnableImageBlockPublicAccessAsync(const EnableImageBlockPublicAccessRequestT& request,
                                         const EnableImageBlockPublicAccessResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableImageBlockPublicAccess, request, handler, context);
  }

  /**
   * <p>Enables deprecation of the specified AMI at the specified date and time.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html">Deprecate
   * an AMI</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableImageDeprecation">AWS
   * API Reference</a></p>
   */
  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 <typename EnableImageDeprecationRequestT = Model::EnableImageDeprecationRequest>
  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 <typename EnableImageDeprecationRequestT = Model::EnableImageDeprecationRequest>
  void EnableImageDeprecationAsync(const EnableImageDeprecationRequestT& request,
                                   const EnableImageDeprecationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableImageDeprecation, request, handler, context);
  }

  /**
   * <p>Enables deregistration protection for an AMI. When deregistration protection
   * is enabled, the AMI can't be deregistered.</p> <p>To allow the AMI to be
   * deregistered, you must first disable deregistration protection.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deregistration-protection.html">Protect
   * an Amazon EC2 AMI from deregistration</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableImageDeregistrationProtection">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableImageDeregistrationProtectionOutcome EnableImageDeregistrationProtection(
      const Model::EnableImageDeregistrationProtectionRequest& request) const;

  /**
   * A Callable wrapper for EnableImageDeregistrationProtection that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename EnableImageDeregistrationProtectionRequestT = Model::EnableImageDeregistrationProtectionRequest>
  Model::EnableImageDeregistrationProtectionOutcomeCallable EnableImageDeregistrationProtectionCallable(
      const EnableImageDeregistrationProtectionRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableImageDeregistrationProtection, request);
  }

  /**
   * An Async wrapper for EnableImageDeregistrationProtection that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename EnableImageDeregistrationProtectionRequestT = Model::EnableImageDeregistrationProtectionRequest>
  void EnableImageDeregistrationProtectionAsync(const EnableImageDeregistrationProtectionRequestT& request,
                                                const EnableImageDeregistrationProtectionResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableImageDeregistrationProtection, request, handler, context);
  }

  /**
   * <p>Enable Amazon EC2 instances running in an SQL Server High Availability
   * cluster for SQL Server High Availability instance standby detection monitoring.
   * Once enabled, Amazon Web Services monitors the metadata for the instances to
   * determine whether they are active or standby nodes in the SQL Server High
   * Availability cluster. If the instances are determined to be standby failover
   * nodes, Amazon Web Services automatically applies SQL Server licensing fee waiver
   * for those instances.</p> <p>To register an instance, it must be running a
   * Windows SQL Server license-included AMI and have the Amazon Web Services Systems
   * Manager agent installed and running. Only Windows Server 2019 and later and SQL
   * Server (Standard and Enterprise editions) 2017 and later are supported. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/sql-server-ec2/latest/userguide/prerequisites-and-requirements.html">
   * Prerequisites for using SQL Server High Availability instance standby
   * detection</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableInstanceSqlHaStandbyDetections">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableInstanceSqlHaStandbyDetectionsOutcome EnableInstanceSqlHaStandbyDetections(
      const Model::EnableInstanceSqlHaStandbyDetectionsRequest& request) const;

  /**
   * A Callable wrapper for EnableInstanceSqlHaStandbyDetections that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename EnableInstanceSqlHaStandbyDetectionsRequestT = Model::EnableInstanceSqlHaStandbyDetectionsRequest>
  Model::EnableInstanceSqlHaStandbyDetectionsOutcomeCallable EnableInstanceSqlHaStandbyDetectionsCallable(
      const EnableInstanceSqlHaStandbyDetectionsRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableInstanceSqlHaStandbyDetections, request);
  }

  /**
   * An Async wrapper for EnableInstanceSqlHaStandbyDetections that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename EnableInstanceSqlHaStandbyDetectionsRequestT = Model::EnableInstanceSqlHaStandbyDetectionsRequest>
  void EnableInstanceSqlHaStandbyDetectionsAsync(const EnableInstanceSqlHaStandbyDetectionsRequestT& request,
                                                 const EnableInstanceSqlHaStandbyDetectionsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableInstanceSqlHaStandbyDetections, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html">Enable
   * integration with Organizations</a> in the <i>Amazon VPC IPAM User Guide</i>.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableIpamOrganizationAdminAccount">AWS
   * API Reference</a></p>
   */
  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 <typename EnableIpamOrganizationAdminAccountRequestT = Model::EnableIpamOrganizationAdminAccountRequest>
  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 <typename EnableIpamOrganizationAdminAccountRequestT = Model::EnableIpamOrganizationAdminAccountRequest>
  void EnableIpamOrganizationAdminAccountAsync(const EnableIpamOrganizationAdminAccountRequestT& request,
                                               const EnableIpamOrganizationAdminAccountResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableIpamOrganizationAdminAccount, request, handler, context);
  }

  /**
   * <p>Enables an IPAM policy.</p> <p>An IPAM policy is a set of rules that define
   * how public IPv4 addresses from IPAM pools are allocated to Amazon Web Services
   * resources. Each rule maps an Amazon Web Services service to IPAM pools that the
   * service will use to get IP addresses. A single policy can have multiple rules
   * and be applied to multiple Amazon Web Services Regions. If the IPAM pool run out
   * of addresses then the services fallback to Amazon-provided IP addresses. A
   * policy can be applied to an individual Amazon Web Services account or an entity
   * within Amazon Web Services Organizations.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/define-public-ipv4-allocation-strategy-with-ipam-policies.html">Define
   * public IPv4 allocation strategy with IPAM policies</a> in the <i>Amazon VPC IPAM
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableIpamPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableIpamPolicyOutcome EnableIpamPolicy(const Model::EnableIpamPolicyRequest& request) const;

  /**
   * A Callable wrapper for EnableIpamPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename EnableIpamPolicyRequestT = Model::EnableIpamPolicyRequest>
  Model::EnableIpamPolicyOutcomeCallable EnableIpamPolicyCallable(const EnableIpamPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableIpamPolicy, request);
  }

  /**
   * An Async wrapper for EnableIpamPolicy that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename EnableIpamPolicyRequestT = Model::EnableIpamPolicyRequest>
  void EnableIpamPolicyAsync(const EnableIpamPolicyRequestT& request, const EnableIpamPolicyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableIpamPolicy, request, handler, context);
  }

  /**
   * <p>Establishes a trust relationship between Reachability Analyzer and
   * Organizations. This operation must be performed by the management account for
   * the organization.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableReachabilityAnalyzerOrganizationSharing">AWS
   * API Reference</a></p>
   */
  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 <typename EnableReachabilityAnalyzerOrganizationSharingRequestT = Model::EnableReachabilityAnalyzerOrganizationSharingRequest>
  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 <typename EnableReachabilityAnalyzerOrganizationSharingRequestT = Model::EnableReachabilityAnalyzerOrganizationSharingRequest>
  void EnableReachabilityAnalyzerOrganizationSharingAsync(
      const EnableReachabilityAnalyzerOrganizationSharingResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const EnableReachabilityAnalyzerOrganizationSharingRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::EnableReachabilityAnalyzerOrganizationSharing, request, handler, context);
  }

  /**
   * <p>Defines which route tables the route server can update with routes.</p>
   * <p>When enabled, route server propagation installs the routes in the FIB on the
   * route table you've specified. Route server supports IPv4 and IPv6 route
   * propagation.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableRouteServerPropagation">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableRouteServerPropagationOutcome EnableRouteServerPropagation(
      const Model::EnableRouteServerPropagationRequest& request) const;

  /**
   * A Callable wrapper for EnableRouteServerPropagation that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename EnableRouteServerPropagationRequestT = Model::EnableRouteServerPropagationRequest>
  Model::EnableRouteServerPropagationOutcomeCallable EnableRouteServerPropagationCallable(
      const EnableRouteServerPropagationRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableRouteServerPropagation, request);
  }

  /**
   * An Async wrapper for EnableRouteServerPropagation that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename EnableRouteServerPropagationRequestT = Model::EnableRouteServerPropagationRequest>
  void EnableRouteServerPropagationAsync(const EnableRouteServerPropagationRequestT& request,
                                         const EnableRouteServerPropagationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableRouteServerPropagation, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configure-access-to-serial-console.html#serial-console-account-access">Manage
   * account access to the EC2 serial console</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableSerialConsoleAccess">AWS
   * API Reference</a></p>
   */
  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 <typename EnableSerialConsoleAccessRequestT = Model::EnableSerialConsoleAccessRequest>
  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 <typename EnableSerialConsoleAccessRequestT = Model::EnableSerialConsoleAccessRequest>
  void EnableSerialConsoleAccessAsync(const EnableSerialConsoleAccessResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const EnableSerialConsoleAccessRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::EnableSerialConsoleAccess, request, handler, context);
  }

  /**
   * <p>Enables or modifies the <i>block public access for snapshots</i> setting at
   * the account level for the specified Amazon Web Services Region. After you enable
   * block public access for snapshots in a Region, users can no longer request
   * public sharing for snapshots in that Region. Snapshots that are already publicly
   * shared are either treated as private or they remain publicly shared, depending
   * on the <b>State</b> that you specify.</p>  <p>Enabling block public
   * access for snapshots in <i>block all sharing</i> mode does not change the
   * permissions for snapshots that are already publicly shared. Instead, it prevents
   * these snapshots from be publicly visible and publicly accessible. Therefore, the
   * attributes for these snapshots still indicate that they are publicly shared,
   * even though they are not publicly available.</p> <p>If you later disable block
   * public access or change the mode to <i>block new sharing</i>, these snapshots
   * will become publicly available again.</p>  <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/block-public-access-snapshots.html">
   * Block public access for snapshots</a> in the <i>Amazon EBS User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableSnapshotBlockPublicAccess">AWS
   * API Reference</a></p>
   */
  virtual Model::EnableSnapshotBlockPublicAccessOutcome EnableSnapshotBlockPublicAccess(
      const Model::EnableSnapshotBlockPublicAccessRequest& request) const;

  /**
   * A Callable wrapper for EnableSnapshotBlockPublicAccess that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename EnableSnapshotBlockPublicAccessRequestT = Model::EnableSnapshotBlockPublicAccessRequest>
  Model::EnableSnapshotBlockPublicAccessOutcomeCallable EnableSnapshotBlockPublicAccessCallable(
      const EnableSnapshotBlockPublicAccessRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableSnapshotBlockPublicAccess, request);
  }

  /**
   * An Async wrapper for EnableSnapshotBlockPublicAccess that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename EnableSnapshotBlockPublicAccessRequestT = Model::EnableSnapshotBlockPublicAccessRequest>
  void EnableSnapshotBlockPublicAccessAsync(const EnableSnapshotBlockPublicAccessRequestT& request,
                                            const EnableSnapshotBlockPublicAccessResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableSnapshotBlockPublicAccess, request, handler, context);
  }

  /**
   * <p>Enables the specified attachment to propagate routes to the specified
   * propagation route table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableTransitGatewayRouteTablePropagation">AWS
   * API Reference</a></p>
   */
  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 <typename EnableTransitGatewayRouteTablePropagationRequestT = Model::EnableTransitGatewayRouteTablePropagationRequest>
  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 <typename EnableTransitGatewayRouteTablePropagationRequestT = Model::EnableTransitGatewayRouteTablePropagationRequest>
  void EnableTransitGatewayRouteTablePropagationAsync(
      const EnableTransitGatewayRouteTablePropagationRequestT& request,
      const EnableTransitGatewayRouteTablePropagationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableTransitGatewayRouteTablePropagation, request, handler, context);
  }

  /**
   * <p>Enables a virtual private gateway (VGW) to propagate routes to the specified
   * route table of a VPC.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVgwRoutePropagation">AWS
   * API Reference</a></p>
   */
  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 <typename EnableVgwRoutePropagationRequestT = Model::EnableVgwRoutePropagationRequest>
  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 <typename EnableVgwRoutePropagationRequestT = Model::EnableVgwRoutePropagationRequest>
  void EnableVgwRoutePropagationAsync(const EnableVgwRoutePropagationRequestT& request,
                                      const EnableVgwRoutePropagationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableVgwRoutePropagation, request, handler, context);
  }

  /**
   * <p>Enables I/O operations for a volume that had I/O operations disabled because
   * the data on the volume was potentially inconsistent.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVolumeIO">AWS
   * API Reference</a></p>
   */
  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 <typename EnableVolumeIORequestT = Model::EnableVolumeIORequest>
  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 <typename EnableVolumeIORequestT = Model::EnableVolumeIORequest>
  void EnableVolumeIOAsync(const EnableVolumeIORequestT& request, const EnableVolumeIOResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableVolumeIO, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>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 <code>10.0.0.0/8</code> IP address range, excluding local
   * routes for VPCs in the <code>10.0.0.0/16</code> and <code>10.1.0.0/16</code> IP
   * address ranges.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVpcClassicLink">AWS
   * API Reference</a></p>
   */
  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 <typename EnableVpcClassicLinkRequestT = Model::EnableVpcClassicLinkRequest>
  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 <typename EnableVpcClassicLinkRequestT = Model::EnableVpcClassicLinkRequest>
  void EnableVpcClassicLinkAsync(const EnableVpcClassicLinkRequestT& request, const EnableVpcClassicLinkResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::EnableVpcClassicLink, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>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.</p> <p>You must specify a VPC ID in the
   * request.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVpcClassicLinkDnsSupport">AWS
   * API Reference</a></p>
   */
  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 <typename EnableVpcClassicLinkDnsSupportRequestT = Model::EnableVpcClassicLinkDnsSupportRequest>
  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 <typename EnableVpcClassicLinkDnsSupportRequestT = Model::EnableVpcClassicLinkDnsSupportRequest>
  void EnableVpcClassicLinkDnsSupportAsync(const EnableVpcClassicLinkDnsSupportResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const EnableVpcClassicLinkDnsSupportRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::EnableVpcClassicLinkDnsSupport, request, handler, context);
  }

  /**
   * <p>Downloads the client certificate revocation list for the specified Client VPN
   * endpoint.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportClientVpnClientCertificateRevocationList">AWS
   * API Reference</a></p>
   */
  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 <typename ExportClientVpnClientCertificateRevocationListRequestT = Model::ExportClientVpnClientCertificateRevocationListRequest>
  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 <typename ExportClientVpnClientCertificateRevocationListRequestT = Model::ExportClientVpnClientCertificateRevocationListRequest>
  void ExportClientVpnClientCertificateRevocationListAsync(
      const ExportClientVpnClientCertificateRevocationListRequestT& request,
      const ExportClientVpnClientCertificateRevocationListResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ExportClientVpnClientCertificateRevocationList, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportClientVpnClientConfiguration">AWS
   * API Reference</a></p>
   */
  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 <typename ExportClientVpnClientConfigurationRequestT = Model::ExportClientVpnClientConfigurationRequest>
  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 <typename ExportClientVpnClientConfigurationRequestT = Model::ExportClientVpnClientConfigurationRequest>
  void ExportClientVpnClientConfigurationAsync(const ExportClientVpnClientConfigurationRequestT& request,
                                               const ExportClientVpnClientConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ExportClientVpnClientConfiguration, request, handler, context);
  }

  /**
   * <p>Exports an Amazon Machine Image (AMI) to a VM file. For more information, see
   * <a
   * href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport_image.html">Exporting
   * a VM directly from an Amazon Machine Image (AMI)</a> in the <i>VM Import/Export
   * User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportImage">AWS API
   * Reference</a></p>
   */
  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 <typename ExportImageRequestT = Model::ExportImageRequest>
  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 <typename ExportImageRequestT = Model::ExportImageRequest>
  void ExportImageAsync(const ExportImageRequestT& request, const ExportImageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ExportImage, request, handler, context);
  }

  /**
   * <p>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.</p> <p>The routes are saved to the specified bucket in a
   * JSON file. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#tgw-export-route-tables">Export
   * route tables to Amazon S3</a> in the <i>Amazon Web Services Transit Gateways
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportTransitGatewayRoutes">AWS
   * API Reference</a></p>
   */
  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 <typename ExportTransitGatewayRoutesRequestT = Model::ExportTransitGatewayRoutesRequest>
  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 <typename ExportTransitGatewayRoutesRequestT = Model::ExportTransitGatewayRoutesRequest>
  void ExportTransitGatewayRoutesAsync(const ExportTransitGatewayRoutesRequestT& request,
                                       const ExportTransitGatewayRoutesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ExportTransitGatewayRoutes, request, handler, context);
  }

  /**
   * <p>Exports the client configuration for a Verified Access
   * instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportVerifiedAccessInstanceClientConfiguration">AWS
   * API Reference</a></p>
   */
  virtual Model::ExportVerifiedAccessInstanceClientConfigurationOutcome ExportVerifiedAccessInstanceClientConfiguration(
      const Model::ExportVerifiedAccessInstanceClientConfigurationRequest& request) const;

  /**
   * A Callable wrapper for ExportVerifiedAccessInstanceClientConfiguration that returns a future to the operation so that it can be
   * executed in parallel to other requests.
   */
  template <
      typename ExportVerifiedAccessInstanceClientConfigurationRequestT = Model::ExportVerifiedAccessInstanceClientConfigurationRequest>
  Model::ExportVerifiedAccessInstanceClientConfigurationOutcomeCallable ExportVerifiedAccessInstanceClientConfigurationCallable(
      const ExportVerifiedAccessInstanceClientConfigurationRequestT& request) const {
    return SubmitCallable(&EC2Client::ExportVerifiedAccessInstanceClientConfiguration, request);
  }

  /**
   * An Async wrapper for ExportVerifiedAccessInstanceClientConfiguration that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  template <
      typename ExportVerifiedAccessInstanceClientConfigurationRequestT = Model::ExportVerifiedAccessInstanceClientConfigurationRequest>
  void ExportVerifiedAccessInstanceClientConfigurationAsync(
      const ExportVerifiedAccessInstanceClientConfigurationRequestT& request,
      const ExportVerifiedAccessInstanceClientConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ExportVerifiedAccessInstanceClientConfiguration, request, handler, context);
  }

  /**
   * <p>Returns the currently negotiated security parameters for an active VPN
   * tunnel, including IKE version, DH groups, encryption algorithms, and integrity
   * algorithms.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetActiveVpnTunnelStatus">AWS
   * API Reference</a></p>
   */
  virtual Model::GetActiveVpnTunnelStatusOutcome GetActiveVpnTunnelStatus(const Model::GetActiveVpnTunnelStatusRequest& request) const;

  /**
   * A Callable wrapper for GetActiveVpnTunnelStatus that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetActiveVpnTunnelStatusRequestT = Model::GetActiveVpnTunnelStatusRequest>
  Model::GetActiveVpnTunnelStatusOutcomeCallable GetActiveVpnTunnelStatusCallable(const GetActiveVpnTunnelStatusRequestT& request) const {
    return SubmitCallable(&EC2Client::GetActiveVpnTunnelStatus, request);
  }

  /**
   * An Async wrapper for GetActiveVpnTunnelStatus that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetActiveVpnTunnelStatusRequestT = Model::GetActiveVpnTunnelStatusRequest>
  void GetActiveVpnTunnelStatusAsync(const GetActiveVpnTunnelStatusRequestT& request,
                                     const GetActiveVpnTunnelStatusResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetActiveVpnTunnelStatus, request, handler, context);
  }

  /**
   * <p>Gets the current state of the Allowed AMIs setting and the list of Allowed
   * AMIs criteria at the account level in the specified Region.</p>  <p>The
   * Allowed AMIs feature does not restrict the AMIs owned by your account.
   * Regardless of the criteria you set, the AMIs created by your account will always
   * be discoverable and usable by users in your account.</p>  <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-allowed-amis.html">Control
   * the discovery and use of AMIs in Amazon EC2 with Allowed AMIs</a> in <i>Amazon
   * EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAllowedImagesSettings">AWS
   * API Reference</a></p>
   */
  virtual Model::GetAllowedImagesSettingsOutcome GetAllowedImagesSettings(const Model::GetAllowedImagesSettingsRequest& request = {}) const;

  /**
   * A Callable wrapper for GetAllowedImagesSettings that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetAllowedImagesSettingsRequestT = Model::GetAllowedImagesSettingsRequest>
  Model::GetAllowedImagesSettingsOutcomeCallable GetAllowedImagesSettingsCallable(
      const GetAllowedImagesSettingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetAllowedImagesSettings, request);
  }

  /**
   * An Async wrapper for GetAllowedImagesSettings that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetAllowedImagesSettingsRequestT = Model::GetAllowedImagesSettingsRequest>
  void GetAllowedImagesSettingsAsync(const GetAllowedImagesSettingsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const GetAllowedImagesSettingsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetAllowedImagesSettings, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAssociatedEnclaveCertificateIamRoles">AWS
   * API Reference</a></p>
   */
  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 <typename GetAssociatedEnclaveCertificateIamRolesRequestT = Model::GetAssociatedEnclaveCertificateIamRolesRequest>
  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 <typename GetAssociatedEnclaveCertificateIamRolesRequestT = Model::GetAssociatedEnclaveCertificateIamRolesRequest>
  void GetAssociatedEnclaveCertificateIamRolesAsync(const GetAssociatedEnclaveCertificateIamRolesRequestT& request,
                                                    const GetAssociatedEnclaveCertificateIamRolesResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetAssociatedEnclaveCertificateIamRoles, request, handler, context);
  }

  /**
   * <p>Gets information about the IPv6 CIDR block associations for a specified IPv6
   * address pool.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAssociatedIpv6PoolCidrs">AWS
   * API Reference</a></p>
   */
  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 <typename GetAssociatedIpv6PoolCidrsRequestT = Model::GetAssociatedIpv6PoolCidrsRequest>
  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 <typename GetAssociatedIpv6PoolCidrsRequestT = Model::GetAssociatedIpv6PoolCidrsRequest>
  void GetAssociatedIpv6PoolCidrsAsync(const GetAssociatedIpv6PoolCidrsRequestT& request,
                                       const GetAssociatedIpv6PoolCidrsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetAssociatedIpv6PoolCidrs, request, handler, context);
  }

  /**
   * <p>Gets network performance data.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAwsNetworkPerformanceData">AWS
   * API Reference</a></p>
   */
  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 <typename GetAwsNetworkPerformanceDataRequestT = Model::GetAwsNetworkPerformanceDataRequest>
  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 <typename GetAwsNetworkPerformanceDataRequestT = Model::GetAwsNetworkPerformanceDataRequest>
  void GetAwsNetworkPerformanceDataAsync(const GetAwsNetworkPerformanceDataResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetAwsNetworkPerformanceDataRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetAwsNetworkPerformanceData, request, handler, context);
  }

  /**
   * <p> Retrieves the current configuration and status of EC2 Capacity Manager for
   * your account, including enablement status, Organizations access settings, and
   * data ingestion status. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCapacityManagerAttributes">AWS
   * API Reference</a></p>
   */
  virtual Model::GetCapacityManagerAttributesOutcome GetCapacityManagerAttributes(
      const Model::GetCapacityManagerAttributesRequest& request = {}) const;

  /**
   * A Callable wrapper for GetCapacityManagerAttributes that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetCapacityManagerAttributesRequestT = Model::GetCapacityManagerAttributesRequest>
  Model::GetCapacityManagerAttributesOutcomeCallable GetCapacityManagerAttributesCallable(
      const GetCapacityManagerAttributesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetCapacityManagerAttributes, request);
  }

  /**
   * An Async wrapper for GetCapacityManagerAttributes that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetCapacityManagerAttributesRequestT = Model::GetCapacityManagerAttributesRequest>
  void GetCapacityManagerAttributesAsync(const GetCapacityManagerAttributesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetCapacityManagerAttributesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetCapacityManagerAttributes, request, handler, context);
  }

  /**
   * <p> Retrieves capacity usage metrics for your EC2 resources. Returns time-series
   * data for metrics like unused capacity, utilization rates, and costs across
   * On-Demand, Spot, and Capacity Reservations. Data can be grouped and filtered by
   * various dimensions such as region, account, and instance family. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCapacityManagerMetricData">AWS
   * API Reference</a></p>
   */
  virtual Model::GetCapacityManagerMetricDataOutcome GetCapacityManagerMetricData(
      const Model::GetCapacityManagerMetricDataRequest& request) const;

  /**
   * A Callable wrapper for GetCapacityManagerMetricData that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetCapacityManagerMetricDataRequestT = Model::GetCapacityManagerMetricDataRequest>
  Model::GetCapacityManagerMetricDataOutcomeCallable GetCapacityManagerMetricDataCallable(
      const GetCapacityManagerMetricDataRequestT& request) const {
    return SubmitCallable(&EC2Client::GetCapacityManagerMetricData, request);
  }

  /**
   * An Async wrapper for GetCapacityManagerMetricData that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetCapacityManagerMetricDataRequestT = Model::GetCapacityManagerMetricDataRequest>
  void GetCapacityManagerMetricDataAsync(const GetCapacityManagerMetricDataRequestT& request,
                                         const GetCapacityManagerMetricDataResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetCapacityManagerMetricData, request, handler, context);
  }

  /**
   * <p> Retrieves the available dimension values for capacity metrics within a
   * specified time range. This is useful for discovering what accounts, regions,
   * instance families, and other dimensions have data available for filtering and
   * grouping. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCapacityManagerMetricDimensions">AWS
   * API Reference</a></p>
   */
  virtual Model::GetCapacityManagerMetricDimensionsOutcome GetCapacityManagerMetricDimensions(
      const Model::GetCapacityManagerMetricDimensionsRequest& request) const;

  /**
   * A Callable wrapper for GetCapacityManagerMetricDimensions that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GetCapacityManagerMetricDimensionsRequestT = Model::GetCapacityManagerMetricDimensionsRequest>
  Model::GetCapacityManagerMetricDimensionsOutcomeCallable GetCapacityManagerMetricDimensionsCallable(
      const GetCapacityManagerMetricDimensionsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetCapacityManagerMetricDimensions, request);
  }

  /**
   * An Async wrapper for GetCapacityManagerMetricDimensions that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename GetCapacityManagerMetricDimensionsRequestT = Model::GetCapacityManagerMetricDimensionsRequest>
  void GetCapacityManagerMetricDimensionsAsync(const GetCapacityManagerMetricDimensionsRequestT& request,
                                               const GetCapacityManagerMetricDimensionsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetCapacityManagerMetricDimensions, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCapacityReservationUsage">AWS
   * API Reference</a></p>
   */
  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 <typename GetCapacityReservationUsageRequestT = Model::GetCapacityReservationUsageRequest>
  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 <typename GetCapacityReservationUsageRequestT = Model::GetCapacityReservationUsageRequest>
  void GetCapacityReservationUsageAsync(const GetCapacityReservationUsageRequestT& request,
                                        const GetCapacityReservationUsageResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetCapacityReservationUsage, request, handler, context);
  }

  /**
   * <p>Describes the allocations from the specified customer-owned address
   * pool.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCoipPoolUsage">AWS
   * API Reference</a></p>
   */
  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 <typename GetCoipPoolUsageRequestT = Model::GetCoipPoolUsageRequest>
  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 <typename GetCoipPoolUsageRequestT = Model::GetCoipPoolUsageRequest>
  void GetCoipPoolUsageAsync(const GetCoipPoolUsageRequestT& request, const GetCoipPoolUsageResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetCoipPoolUsage, request, handler, context);
  }

  /**
   * <p>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.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html#instance-console-console-output">Instance
   * console output</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetConsoleOutput">AWS
   * API Reference</a></p>
   */
  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 <typename GetConsoleOutputRequestT = Model::GetConsoleOutputRequest>
  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 <typename GetConsoleOutputRequestT = Model::GetConsoleOutputRequest>
  void GetConsoleOutputAsync(const GetConsoleOutputRequestT& request, const GetConsoleOutputResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetConsoleOutput, request, handler, context);
  }

  /**
   * <p>Retrieve a JPG-format screenshot of a running instance to help with
   * troubleshooting.</p> <p>The returned content is Base64-encoded.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/troubleshoot-unreachable-instance.html#instance-console-console-output">Instance
   * console output</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetConsoleScreenshot">AWS
   * API Reference</a></p>
   */
  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 <typename GetConsoleScreenshotRequestT = Model::GetConsoleScreenshotRequest>
  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 <typename GetConsoleScreenshotRequestT = Model::GetConsoleScreenshotRequest>
  void GetConsoleScreenshotAsync(const GetConsoleScreenshotRequestT& request, const GetConsoleScreenshotResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetConsoleScreenshot, request, handler, context);
  }

  /**
   * <p>Retrieves a summary of the account status report.</p> <p>To view the full
   * report, download it from the Amazon S3 bucket where it was saved. Reports are
   * accessible only when they have the <code>complete</code> status. Reports with
   * other statuses (<code>running</code>, <code>cancelled</code>, or
   * <code>error</code>) are not available in the S3 bucket. For more information
   * about downloading objects from an S3 bucket, see <a
   * href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/download-objects.html">Downloading
   * objects</a> in the <i>Amazon Simple Storage Service User Guide</i>.</p> <p>For
   * more information, see <a
   * href="https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_declarative_status-report.html">Generating
   * the account status report for declarative policies</a> in the <i>Amazon Web
   * Services Organizations User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetDeclarativePoliciesReportSummary">AWS
   * API Reference</a></p>
   */
  virtual Model::GetDeclarativePoliciesReportSummaryOutcome GetDeclarativePoliciesReportSummary(
      const Model::GetDeclarativePoliciesReportSummaryRequest& request) const;

  /**
   * A Callable wrapper for GetDeclarativePoliciesReportSummary that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename GetDeclarativePoliciesReportSummaryRequestT = Model::GetDeclarativePoliciesReportSummaryRequest>
  Model::GetDeclarativePoliciesReportSummaryOutcomeCallable GetDeclarativePoliciesReportSummaryCallable(
      const GetDeclarativePoliciesReportSummaryRequestT& request) const {
    return SubmitCallable(&EC2Client::GetDeclarativePoliciesReportSummary, request);
  }

  /**
   * An Async wrapper for GetDeclarativePoliciesReportSummary that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename GetDeclarativePoliciesReportSummaryRequestT = Model::GetDeclarativePoliciesReportSummaryRequest>
  void GetDeclarativePoliciesReportSummaryAsync(const GetDeclarativePoliciesReportSummaryRequestT& request,
                                                const GetDeclarativePoliciesReportSummaryResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetDeclarativePoliciesReportSummary, request, handler, context);
  }

  /**
   * <p>Describes the default credit option for CPU usage of a burstable performance
   * instance family.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html">Burstable
   * performance instances</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetDefaultCreditSpecification">AWS
   * API Reference</a></p>
   */
  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 <typename GetDefaultCreditSpecificationRequestT = Model::GetDefaultCreditSpecificationRequest>
  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 <typename GetDefaultCreditSpecificationRequestT = Model::GetDefaultCreditSpecificationRequest>
  void GetDefaultCreditSpecificationAsync(const GetDefaultCreditSpecificationRequestT& request,
                                          const GetDefaultCreditSpecificationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetDefaultCreditSpecification, request, handler, context);
  }

  /**
   * <p>Describes the default KMS key for EBS encryption by default for your account
   * in this Region.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html">Amazon
   * EBS encryption</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetEbsDefaultKmsKeyId">AWS
   * API Reference</a></p>
   */
  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 <typename GetEbsDefaultKmsKeyIdRequestT = Model::GetEbsDefaultKmsKeyIdRequest>
  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 <typename GetEbsDefaultKmsKeyIdRequestT = Model::GetEbsDefaultKmsKeyIdRequest>
  void GetEbsDefaultKmsKeyIdAsync(const GetEbsDefaultKmsKeyIdResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const GetEbsDefaultKmsKeyIdRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetEbsDefaultKmsKeyId, request, handler, context);
  }

  /**
   * <p>Describes whether EBS encryption by default is enabled for your account in
   * the current Region.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html">Amazon
   * EBS encryption</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetEbsEncryptionByDefault">AWS
   * API Reference</a></p>
   */
  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 <typename GetEbsEncryptionByDefaultRequestT = Model::GetEbsEncryptionByDefaultRequest>
  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 <typename GetEbsEncryptionByDefaultRequestT = Model::GetEbsEncryptionByDefaultRequest>
  void GetEbsEncryptionByDefaultAsync(const GetEbsEncryptionByDefaultResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const GetEbsEncryptionByDefaultRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetEbsEncryptionByDefault, request, handler, context);
  }

  /**
   * <p>Gets the enabled IPAM policy.</p> <p>An IPAM policy is a set of rules that
   * define how public IPv4 addresses from IPAM pools are allocated to Amazon Web
   * Services resources. Each rule maps an Amazon Web Services service to IPAM pools
   * that the service will use to get IP addresses. A single policy can have multiple
   * rules and be applied to multiple Amazon Web Services Regions. If the IPAM pool
   * run out of addresses then the services fallback to Amazon-provided IP addresses.
   * A policy can be applied to an individual Amazon Web Services account or an
   * entity within Amazon Web Services Organizations.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetEnabledIpamPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::GetEnabledIpamPolicyOutcome GetEnabledIpamPolicy(const Model::GetEnabledIpamPolicyRequest& request = {}) const;

  /**
   * A Callable wrapper for GetEnabledIpamPolicy that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetEnabledIpamPolicyRequestT = Model::GetEnabledIpamPolicyRequest>
  Model::GetEnabledIpamPolicyOutcomeCallable GetEnabledIpamPolicyCallable(const GetEnabledIpamPolicyRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetEnabledIpamPolicy, request);
  }

  /**
   * An Async wrapper for GetEnabledIpamPolicy that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetEnabledIpamPolicyRequestT = Model::GetEnabledIpamPolicyRequest>
  void GetEnabledIpamPolicyAsync(const GetEnabledIpamPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const GetEnabledIpamPolicyRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetEnabledIpamPolicy, request, handler, context);
  }

  /**
   * <p>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:</p>
   * <ul> <li> <p>Create a table in Athena that maps fields to a custom log
   * format</p> </li> <li> <p>Create a Lambda function that updates the table with
   * new partitions on a daily, weekly, or monthly basis</p> </li> <li> <p>Create a
   * table partitioned between two timestamps in the past</p> </li> <li> <p>Create a
   * set of named queries in Athena that you can use to get started quickly</p> </li>
   * </ul>  <p> <code>GetFlowLogsIntegrationTemplate</code> does not support
   * integration between Amazon Web Services Transit Gateway Flow Logs and Amazon
   * Athena.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetFlowLogsIntegrationTemplate">AWS
   * API Reference</a></p>
   */
  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 <typename GetFlowLogsIntegrationTemplateRequestT = Model::GetFlowLogsIntegrationTemplateRequest>
  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 <typename GetFlowLogsIntegrationTemplateRequestT = Model::GetFlowLogsIntegrationTemplateRequest>
  void GetFlowLogsIntegrationTemplateAsync(const GetFlowLogsIntegrationTemplateRequestT& request,
                                           const GetFlowLogsIntegrationTemplateResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetFlowLogsIntegrationTemplate, request, handler, context);
  }

  /**
   * <p>Lists the resource groups to which a Capacity Reservation has been
   * added.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetGroupsForCapacityReservation">AWS
   * API Reference</a></p>
   */
  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 <typename GetGroupsForCapacityReservationRequestT = Model::GetGroupsForCapacityReservationRequest>
  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 <typename GetGroupsForCapacityReservationRequestT = Model::GetGroupsForCapacityReservationRequest>
  void GetGroupsForCapacityReservationAsync(const GetGroupsForCapacityReservationRequestT& request,
                                            const GetGroupsForCapacityReservationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetGroupsForCapacityReservation, request, handler, context);
  }

  /**
   * <p>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.</p> <p>This is a preview of the
   * <a>PurchaseHostReservation</a> action and does not result in the offering being
   * purchased.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetHostReservationPurchasePreview">AWS
   * API Reference</a></p>
   */
  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 <typename GetHostReservationPurchasePreviewRequestT = Model::GetHostReservationPurchasePreviewRequest>
  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 <typename GetHostReservationPurchasePreviewRequestT = Model::GetHostReservationPurchasePreviewRequest>
  void GetHostReservationPurchasePreviewAsync(const GetHostReservationPurchasePreviewRequestT& request,
                                              const GetHostReservationPurchasePreviewResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetHostReservationPurchasePreview, request, handler, context);
  }

  /**
   * <p>Retrieves the ancestry chain of the specified AMI, tracing its lineage back
   * to the root AMI. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-ancestry.html">AMI
   * ancestry</a> in <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetImageAncestry">AWS
   * API Reference</a></p>
   */
  virtual Model::GetImageAncestryOutcome GetImageAncestry(const Model::GetImageAncestryRequest& request) const;

  /**
   * A Callable wrapper for GetImageAncestry that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetImageAncestryRequestT = Model::GetImageAncestryRequest>
  Model::GetImageAncestryOutcomeCallable GetImageAncestryCallable(const GetImageAncestryRequestT& request) const {
    return SubmitCallable(&EC2Client::GetImageAncestry, request);
  }

  /**
   * An Async wrapper for GetImageAncestry that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename GetImageAncestryRequestT = Model::GetImageAncestryRequest>
  void GetImageAncestryAsync(const GetImageAncestryRequestT& request, const GetImageAncestryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetImageAncestry, request, handler, context);
  }

  /**
   * <p>Gets the current state of <i>block public access for AMIs</i> at the account
   * level in the specified Amazon Web Services Region.</p> <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-to-amis.html">Block
   * public access to your AMIs</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetImageBlockPublicAccessState">AWS
   * API Reference</a></p>
   */
  virtual Model::GetImageBlockPublicAccessStateOutcome GetImageBlockPublicAccessState(
      const Model::GetImageBlockPublicAccessStateRequest& request = {}) const;

  /**
   * A Callable wrapper for GetImageBlockPublicAccessState that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetImageBlockPublicAccessStateRequestT = Model::GetImageBlockPublicAccessStateRequest>
  Model::GetImageBlockPublicAccessStateOutcomeCallable GetImageBlockPublicAccessStateCallable(
      const GetImageBlockPublicAccessStateRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetImageBlockPublicAccessState, request);
  }

  /**
   * An Async wrapper for GetImageBlockPublicAccessState that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename GetImageBlockPublicAccessStateRequestT = Model::GetImageBlockPublicAccessStateRequest>
  void GetImageBlockPublicAccessStateAsync(const GetImageBlockPublicAccessStateResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const GetImageBlockPublicAccessStateRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetImageBlockPublicAccessState, request, handler, context);
  }

  /**
   * <p>Gets the default instance metadata service (IMDS) settings that are set at
   * the account level in the specified Amazon Web Services&#x2028; Region.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-options.html#instance-metadata-options-order-of-precedence">Order
   * of precedence for instance metadata options</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceMetadataDefaults">AWS
   * API Reference</a></p>
   */
  virtual Model::GetInstanceMetadataDefaultsOutcome GetInstanceMetadataDefaults(
      const Model::GetInstanceMetadataDefaultsRequest& request = {}) const;

  /**
   * A Callable wrapper for GetInstanceMetadataDefaults that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetInstanceMetadataDefaultsRequestT = Model::GetInstanceMetadataDefaultsRequest>
  Model::GetInstanceMetadataDefaultsOutcomeCallable GetInstanceMetadataDefaultsCallable(
      const GetInstanceMetadataDefaultsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetInstanceMetadataDefaults, request);
  }

  /**
   * An Async wrapper for GetInstanceMetadataDefaults that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetInstanceMetadataDefaultsRequestT = Model::GetInstanceMetadataDefaultsRequest>
  void GetInstanceMetadataDefaultsAsync(const GetInstanceMetadataDefaultsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const GetInstanceMetadataDefaultsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetInstanceMetadataDefaults, request, handler, context);
  }

  /**
   * <p>Gets the public endorsement key associated with the Nitro Trusted Platform
   * Module (NitroTPM) for the specified instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceTpmEkPub">AWS
   * API Reference</a></p>
   */
  virtual Model::GetInstanceTpmEkPubOutcome GetInstanceTpmEkPub(const Model::GetInstanceTpmEkPubRequest& request) const;

  /**
   * A Callable wrapper for GetInstanceTpmEkPub that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetInstanceTpmEkPubRequestT = Model::GetInstanceTpmEkPubRequest>
  Model::GetInstanceTpmEkPubOutcomeCallable GetInstanceTpmEkPubCallable(const GetInstanceTpmEkPubRequestT& request) const {
    return SubmitCallable(&EC2Client::GetInstanceTpmEkPub, request);
  }

  /**
   * An Async wrapper for GetInstanceTpmEkPub that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename GetInstanceTpmEkPubRequestT = Model::GetInstanceTpmEkPubRequest>
  void GetInstanceTpmEkPubAsync(const GetInstanceTpmEkPubRequestT& request, const GetInstanceTpmEkPubResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetInstanceTpmEkPub, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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.</p> <p>For more information, see
   * <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html#ec2fleet-get-instance-types-from-instance-requirements">Preview
   * instance types with specified attributes</a>, <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html">Specify
   * attributes for instance type selection for EC2 Fleet or Spot Fleet</a>, and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html">Spot
   * placement score</a> in the <i>Amazon EC2 User Guide</i>, and <a
   * href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-asg-instance-type-requirements.html">Creating
   * mixed instance groups using attribute-based instance type selection</a> in the
   * <i>Amazon EC2 Auto Scaling User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceTypesFromInstanceRequirements">AWS
   * API Reference</a></p>
   */
  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 <typename GetInstanceTypesFromInstanceRequirementsRequestT = Model::GetInstanceTypesFromInstanceRequirementsRequest>
  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 <typename GetInstanceTypesFromInstanceRequirementsRequestT = Model::GetInstanceTypesFromInstanceRequirementsRequest>
  void GetInstanceTypesFromInstanceRequirementsAsync(
      const GetInstanceTypesFromInstanceRequirementsRequestT& request,
      const GetInstanceTypesFromInstanceRequirementsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetInstanceTypesFromInstanceRequirements, request, handler, context);
  }

  /**
   * <p>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.</p> <p>When you use <a
   * href="https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html">register-image</a>
   * to create an AMI, you can create an exact copy of your variable store by passing
   * the UEFI data in the <code>UefiData</code> parameter. You can modify the UEFI
   * data by using the <a
   * href="https://github.com/awslabs/python-uefivars">python-uefivars tool</a> 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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/uefi-secure-boot.html">UEFI
   * Secure Boot</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceUefiData">AWS
   * API Reference</a></p>
   */
  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 <typename GetInstanceUefiDataRequestT = Model::GetInstanceUefiDataRequest>
  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 <typename GetInstanceUefiDataRequestT = Model::GetInstanceUefiDataRequest>
  void GetInstanceUefiDataAsync(const GetInstanceUefiDataRequestT& request, const GetInstanceUefiDataResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetInstanceUefiData, request, handler, context);
  }

  /**
   * <p>Retrieve historical information about a CIDR within an IPAM scope. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/view-history-cidr-ipam.html">View
   * the history of IP addresses</a> in the <i>Amazon VPC IPAM User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamAddressHistory">AWS
   * API Reference</a></p>
   */
  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 <typename GetIpamAddressHistoryRequestT = Model::GetIpamAddressHistoryRequest>
  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 <typename GetIpamAddressHistoryRequestT = Model::GetIpamAddressHistoryRequest>
  void GetIpamAddressHistoryAsync(const GetIpamAddressHistoryRequestT& request, const GetIpamAddressHistoryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamAddressHistory, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamDiscoveredAccounts">AWS
   * API Reference</a></p>
   */
  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 <typename GetIpamDiscoveredAccountsRequestT = Model::GetIpamDiscoveredAccountsRequest>
  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 <typename GetIpamDiscoveredAccountsRequestT = Model::GetIpamDiscoveredAccountsRequest>
  void GetIpamDiscoveredAccountsAsync(const GetIpamDiscoveredAccountsRequestT& request,
                                      const GetIpamDiscoveredAccountsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamDiscoveredAccounts, request, handler, context);
  }

  /**
   * <p>Gets the public IP addresses that have been discovered by IPAM.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamDiscoveredPublicAddresses">AWS
   * API Reference</a></p>
   */
  virtual Model::GetIpamDiscoveredPublicAddressesOutcome GetIpamDiscoveredPublicAddresses(
      const Model::GetIpamDiscoveredPublicAddressesRequest& request) const;

  /**
   * A Callable wrapper for GetIpamDiscoveredPublicAddresses that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GetIpamDiscoveredPublicAddressesRequestT = Model::GetIpamDiscoveredPublicAddressesRequest>
  Model::GetIpamDiscoveredPublicAddressesOutcomeCallable GetIpamDiscoveredPublicAddressesCallable(
      const GetIpamDiscoveredPublicAddressesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamDiscoveredPublicAddresses, request);
  }

  /**
   * An Async wrapper for GetIpamDiscoveredPublicAddresses that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename GetIpamDiscoveredPublicAddressesRequestT = Model::GetIpamDiscoveredPublicAddressesRequest>
  void GetIpamDiscoveredPublicAddressesAsync(const GetIpamDiscoveredPublicAddressesRequestT& request,
                                             const GetIpamDiscoveredPublicAddressesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamDiscoveredPublicAddresses, request, handler, context);
  }

  /**
   * <p>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. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamDiscoveredResourceCidrs">AWS
   * API Reference</a></p>
   */
  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 <typename GetIpamDiscoveredResourceCidrsRequestT = Model::GetIpamDiscoveredResourceCidrsRequest>
  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 <typename GetIpamDiscoveredResourceCidrsRequestT = Model::GetIpamDiscoveredResourceCidrsRequest>
  void GetIpamDiscoveredResourceCidrsAsync(const GetIpamDiscoveredResourceCidrsRequestT& request,
                                           const GetIpamDiscoveredResourceCidrsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamDiscoveredResourceCidrs, request, handler, context);
  }

  /**
   * <p>Gets the allocation rules for an IPAM policy.</p> <p>An IPAM policy is a set
   * of rules that define how public IPv4 addresses from IPAM pools are allocated to
   * Amazon Web Services resources. Each rule maps an Amazon Web Services service to
   * IPAM pools that the service will use to get IP addresses. A single policy can
   * have multiple rules and be applied to multiple Amazon Web Services Regions. If
   * the IPAM pool run out of addresses then the services fallback to Amazon-provided
   * IP addresses. A policy can be applied to an individual Amazon Web Services
   * account or an entity within Amazon Web Services Organizations.</p> <p>Allocation
   * rules are optional configurations within an IPAM policy that map Amazon Web
   * Services resource types to specific IPAM pools. If no rules are defined, the
   * resource types default to using Amazon-provided IP addresses.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPolicyAllocationRules">AWS
   * API Reference</a></p>
   */
  virtual Model::GetIpamPolicyAllocationRulesOutcome GetIpamPolicyAllocationRules(
      const Model::GetIpamPolicyAllocationRulesRequest& request) const;

  /**
   * A Callable wrapper for GetIpamPolicyAllocationRules that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetIpamPolicyAllocationRulesRequestT = Model::GetIpamPolicyAllocationRulesRequest>
  Model::GetIpamPolicyAllocationRulesOutcomeCallable GetIpamPolicyAllocationRulesCallable(
      const GetIpamPolicyAllocationRulesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPolicyAllocationRules, request);
  }

  /**
   * An Async wrapper for GetIpamPolicyAllocationRules that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetIpamPolicyAllocationRulesRequestT = Model::GetIpamPolicyAllocationRulesRequest>
  void GetIpamPolicyAllocationRulesAsync(const GetIpamPolicyAllocationRulesRequestT& request,
                                         const GetIpamPolicyAllocationRulesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamPolicyAllocationRules, request, handler, context);
  }

  /**
   * <p>Gets the Amazon Web Services Organizations targets for an IPAM policy.</p>
   * <p>An IPAM policy is a set of rules that define how public IPv4 addresses from
   * IPAM pools are allocated to Amazon Web Services resources. Each rule maps an
   * Amazon Web Services service to IPAM pools that the service will use to get IP
   * addresses. A single policy can have multiple rules and be applied to multiple
   * Amazon Web Services Regions. If the IPAM pool run out of addresses then the
   * services fallback to Amazon-provided IP addresses. A policy can be applied to an
   * individual Amazon Web Services account or an entity within Amazon Web Services
   * Organizations.</p> <p>A target can be an individual Amazon Web Services account
   * or an entity within an Amazon Web Services Organization to which an IPAM policy
   * can be applied.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPolicyOrganizationTargets">AWS
   * API Reference</a></p>
   */
  virtual Model::GetIpamPolicyOrganizationTargetsOutcome GetIpamPolicyOrganizationTargets(
      const Model::GetIpamPolicyOrganizationTargetsRequest& request) const;

  /**
   * A Callable wrapper for GetIpamPolicyOrganizationTargets that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GetIpamPolicyOrganizationTargetsRequestT = Model::GetIpamPolicyOrganizationTargetsRequest>
  Model::GetIpamPolicyOrganizationTargetsOutcomeCallable GetIpamPolicyOrganizationTargetsCallable(
      const GetIpamPolicyOrganizationTargetsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPolicyOrganizationTargets, request);
  }

  /**
   * An Async wrapper for GetIpamPolicyOrganizationTargets that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename GetIpamPolicyOrganizationTargetsRequestT = Model::GetIpamPolicyOrganizationTargetsRequest>
  void GetIpamPolicyOrganizationTargetsAsync(const GetIpamPolicyOrganizationTargetsRequestT& request,
                                             const GetIpamPolicyOrganizationTargetsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamPolicyOrganizationTargets, request, handler, context);
  }

  /**
   * <p>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.</p>  <p>If you use this
   * action after <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateIpamPoolCidr.html">AllocateIpamPoolCidr</a>
   * or <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseIpamPoolAllocation.html">ReleaseIpamPoolAllocation</a>,
   * note that all EC2 API actions follow an <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/eventual-consistency.html">eventual
   * consistency</a> model.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPoolAllocations">AWS
   * API Reference</a></p>
   */
  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 <typename GetIpamPoolAllocationsRequestT = Model::GetIpamPoolAllocationsRequest>
  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 <typename GetIpamPoolAllocationsRequestT = Model::GetIpamPoolAllocationsRequest>
  void GetIpamPoolAllocationsAsync(const GetIpamPoolAllocationsRequestT& request,
                                   const GetIpamPoolAllocationsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamPoolAllocations, request, handler, context);
  }

  /**
   * <p>Get the CIDRs provisioned to an IPAM pool.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPoolCidrs">AWS
   * API Reference</a></p>
   */
  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 <typename GetIpamPoolCidrsRequestT = Model::GetIpamPoolCidrsRequest>
  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 <typename GetIpamPoolCidrsRequestT = Model::GetIpamPoolCidrsRequest>
  void GetIpamPoolCidrsAsync(const GetIpamPoolCidrsRequestT& request, const GetIpamPoolCidrsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamPoolCidrs, request, handler, context);
  }

  /**
   * <p>Retrieves the CIDR selection rules for an IPAM prefix list resolver. Use this
   * operation to view the business logic that determines which CIDRs are selected
   * for synchronization with prefix lists.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPrefixListResolverRules">AWS
   * API Reference</a></p>
   */
  virtual Model::GetIpamPrefixListResolverRulesOutcome GetIpamPrefixListResolverRules(
      const Model::GetIpamPrefixListResolverRulesRequest& request) const;

  /**
   * A Callable wrapper for GetIpamPrefixListResolverRules that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetIpamPrefixListResolverRulesRequestT = Model::GetIpamPrefixListResolverRulesRequest>
  Model::GetIpamPrefixListResolverRulesOutcomeCallable GetIpamPrefixListResolverRulesCallable(
      const GetIpamPrefixListResolverRulesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPrefixListResolverRules, request);
  }

  /**
   * An Async wrapper for GetIpamPrefixListResolverRules that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename GetIpamPrefixListResolverRulesRequestT = Model::GetIpamPrefixListResolverRulesRequest>
  void GetIpamPrefixListResolverRulesAsync(const GetIpamPrefixListResolverRulesRequestT& request,
                                           const GetIpamPrefixListResolverRulesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamPrefixListResolverRules, request, handler, context);
  }

  /**
   * <p>Retrieves the CIDR entries for a specific version of an IPAM prefix list
   * resolver. This shows the actual CIDRs that were selected and synchronized at a
   * particular point in time.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPrefixListResolverVersionEntries">AWS
   * API Reference</a></p>
   */
  virtual Model::GetIpamPrefixListResolverVersionEntriesOutcome GetIpamPrefixListResolverVersionEntries(
      const Model::GetIpamPrefixListResolverVersionEntriesRequest& request) const;

  /**
   * A Callable wrapper for GetIpamPrefixListResolverVersionEntries that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename GetIpamPrefixListResolverVersionEntriesRequestT = Model::GetIpamPrefixListResolverVersionEntriesRequest>
  Model::GetIpamPrefixListResolverVersionEntriesOutcomeCallable GetIpamPrefixListResolverVersionEntriesCallable(
      const GetIpamPrefixListResolverVersionEntriesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPrefixListResolverVersionEntries, request);
  }

  /**
   * An Async wrapper for GetIpamPrefixListResolverVersionEntries that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename GetIpamPrefixListResolverVersionEntriesRequestT = Model::GetIpamPrefixListResolverVersionEntriesRequest>
  void GetIpamPrefixListResolverVersionEntriesAsync(const GetIpamPrefixListResolverVersionEntriesRequestT& request,
                                                    const GetIpamPrefixListResolverVersionEntriesResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamPrefixListResolverVersionEntries, request, handler, context);
  }

  /**
   * <p>Retrieves version information for an IPAM prefix list resolver.</p> <p>Each
   * version is a snapshot of what CIDRs matched your rules at that moment in time.
   * The version number increments every time the CIDR list changes due to
   * infrastructure changes.</p> <p> <b>Version example:</b> </p> <p> <b>Initial
   * State (Version 1)</b> </p> <p>Production environment:</p> <ul> <li>
   * <p>vpc-prod-web (10.1.0.0/16) - tagged env=prod</p> </li> <li> <p>vpc-prod-db
   * (10.2.0.0/16) - tagged env=prod</p> </li> </ul> <p>Resolver rule: Include all
   * VPCs tagged env=prod</p> <p> <b>Version 1 CIDRs:</b> 10.1.0.0/16,
   * 10.2.0.0/16</p> <p> <b>Infrastructure Change (Version 2)</b> </p> <p>New VPC
   * added:</p> <ul> <li> <p>vpc-prod-api (10.3.0.0/16) - tagged env=prod</p> </li>
   * </ul> <p>IPAM automatically detects the change and creates a new version.</p>
   * <p> <b>Version 2 CIDRs:</b> 10.1.0.0/16, 10.2.0.0/16, 10.3.0.0/16</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPrefixListResolverVersions">AWS
   * API Reference</a></p>
   */
  virtual Model::GetIpamPrefixListResolverVersionsOutcome GetIpamPrefixListResolverVersions(
      const Model::GetIpamPrefixListResolverVersionsRequest& request) const;

  /**
   * A Callable wrapper for GetIpamPrefixListResolverVersions that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GetIpamPrefixListResolverVersionsRequestT = Model::GetIpamPrefixListResolverVersionsRequest>
  Model::GetIpamPrefixListResolverVersionsOutcomeCallable GetIpamPrefixListResolverVersionsCallable(
      const GetIpamPrefixListResolverVersionsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPrefixListResolverVersions, request);
  }

  /**
   * An Async wrapper for GetIpamPrefixListResolverVersions that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename GetIpamPrefixListResolverVersionsRequestT = Model::GetIpamPrefixListResolverVersionsRequest>
  void GetIpamPrefixListResolverVersionsAsync(const GetIpamPrefixListResolverVersionsRequestT& request,
                                              const GetIpamPrefixListResolverVersionsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamPrefixListResolverVersions, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamResourceCidrs">AWS
   * API Reference</a></p>
   */
  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 <typename GetIpamResourceCidrsRequestT = Model::GetIpamResourceCidrsRequest>
  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 <typename GetIpamResourceCidrsRequestT = Model::GetIpamResourceCidrsRequest>
  void GetIpamResourceCidrsAsync(const GetIpamResourceCidrsRequestT& request, const GetIpamResourceCidrsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetIpamResourceCidrs, request, handler, context);
  }

  /**
   * <p>Retrieves the configuration data of the specified instance. You can use this
   * data to create a launch template. </p> <p>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:
   * <code>DescribeSpotInstanceRequests</code>,
   * <code>DescribeInstanceCreditSpecifications</code>, <code>DescribeVolumes</code>,
   * and <code>DescribeInstanceAttribute</code>. Or, you can allow
   * <code>describe*</code> depending on your instance requirements.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetLaunchTemplateData">AWS
   * API Reference</a></p>
   */
  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 <typename GetLaunchTemplateDataRequestT = Model::GetLaunchTemplateDataRequest>
  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 <typename GetLaunchTemplateDataRequestT = Model::GetLaunchTemplateDataRequest>
  void GetLaunchTemplateDataAsync(const GetLaunchTemplateDataRequestT& request, const GetLaunchTemplateDataResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetLaunchTemplateData, request, handler, context);
  }

  /**
   * <p>Gets information about the resources that are associated with the specified
   * managed prefix list.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetManagedPrefixListAssociations">AWS
   * API Reference</a></p>
   */
  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 <typename GetManagedPrefixListAssociationsRequestT = Model::GetManagedPrefixListAssociationsRequest>
  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 <typename GetManagedPrefixListAssociationsRequestT = Model::GetManagedPrefixListAssociationsRequest>
  void GetManagedPrefixListAssociationsAsync(const GetManagedPrefixListAssociationsRequestT& request,
                                             const GetManagedPrefixListAssociationsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetManagedPrefixListAssociations, request, handler, context);
  }

  /**
   * <p>Gets information about the entries for a specified managed prefix
   * list.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetManagedPrefixListEntries">AWS
   * API Reference</a></p>
   */
  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 <typename GetManagedPrefixListEntriesRequestT = Model::GetManagedPrefixListEntriesRequest>
  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 <typename GetManagedPrefixListEntriesRequestT = Model::GetManagedPrefixListEntriesRequest>
  void GetManagedPrefixListEntriesAsync(const GetManagedPrefixListEntriesRequestT& request,
                                        const GetManagedPrefixListEntriesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetManagedPrefixListEntries, request, handler, context);
  }

  /**
   * <p>Gets the findings for the specified Network Access Scope
   * analysis.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetNetworkInsightsAccessScopeAnalysisFindings">AWS
   * API Reference</a></p>
   */
  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 <typename GetNetworkInsightsAccessScopeAnalysisFindingsRequestT = Model::GetNetworkInsightsAccessScopeAnalysisFindingsRequest>
  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 <typename GetNetworkInsightsAccessScopeAnalysisFindingsRequestT = Model::GetNetworkInsightsAccessScopeAnalysisFindingsRequest>
  void GetNetworkInsightsAccessScopeAnalysisFindingsAsync(
      const GetNetworkInsightsAccessScopeAnalysisFindingsRequestT& request,
      const GetNetworkInsightsAccessScopeAnalysisFindingsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetNetworkInsightsAccessScopeAnalysisFindings, request, handler, context);
  }

  /**
   * <p>Gets the content for the specified Network Access Scope.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetNetworkInsightsAccessScopeContent">AWS
   * API Reference</a></p>
   */
  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 <typename GetNetworkInsightsAccessScopeContentRequestT = Model::GetNetworkInsightsAccessScopeContentRequest>
  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 <typename GetNetworkInsightsAccessScopeContentRequestT = Model::GetNetworkInsightsAccessScopeContentRequest>
  void GetNetworkInsightsAccessScopeContentAsync(const GetNetworkInsightsAccessScopeContentRequestT& request,
                                                 const GetNetworkInsightsAccessScopeContentResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetNetworkInsightsAccessScopeContent, request, handler, context);
  }

  /**
   * <p>Retrieves the encrypted administrator password for a running Windows
   * instance.</p> <p>The Windows password is generated at boot by the
   * <code>EC2Config</code> service or <code>EC2Launch</code> scripts (Windows Server
   * 2016 and later). This usually only happens the first time an instance is
   * launched. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingConfig_WinAMI.html">EC2Config</a>
   * and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2launch.html">EC2Launch</a>
   * in the <i>Amazon EC2 User Guide</i>.</p> <p>For the <code>EC2Config</code>
   * service, the password is not generated for rebundled AMIs unless
   * <code>Ec2SetPassword</code> is enabled before bundling.</p> <p>The password is
   * encrypted using the key pair that you specified when you launched the instance.
   * You must provide the corresponding key pair file.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetPasswordData">AWS
   * API Reference</a></p>
   */
  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 <typename GetPasswordDataRequestT = Model::GetPasswordDataRequest>
  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 <typename GetPasswordDataRequestT = Model::GetPasswordDataRequest>
  void GetPasswordDataAsync(const GetPasswordDataRequestT& request, const GetPasswordDataResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetPasswordData, request, handler, context);
  }

  /**
   * <p>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
   * <a>AcceptReservedInstancesExchangeQuote</a> to perform the
   * exchange.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetReservedInstancesExchangeQuote">AWS
   * API Reference</a></p>
   */
  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 <typename GetReservedInstancesExchangeQuoteRequestT = Model::GetReservedInstancesExchangeQuoteRequest>
  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 <typename GetReservedInstancesExchangeQuoteRequestT = Model::GetReservedInstancesExchangeQuoteRequest>
  void GetReservedInstancesExchangeQuoteAsync(const GetReservedInstancesExchangeQuoteRequestT& request,
                                              const GetReservedInstancesExchangeQuoteResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetReservedInstancesExchangeQuote, request, handler, context);
  }

  /**
   * <p>Gets information about the associations for the specified route server.</p>
   * <p>A route server association is the connection established between a route
   * server and a VPC.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetRouteServerAssociations">AWS
   * API Reference</a></p>
   */
  virtual Model::GetRouteServerAssociationsOutcome GetRouteServerAssociations(
      const Model::GetRouteServerAssociationsRequest& request) const;

  /**
   * A Callable wrapper for GetRouteServerAssociations that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetRouteServerAssociationsRequestT = Model::GetRouteServerAssociationsRequest>
  Model::GetRouteServerAssociationsOutcomeCallable GetRouteServerAssociationsCallable(
      const GetRouteServerAssociationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetRouteServerAssociations, request);
  }

  /**
   * An Async wrapper for GetRouteServerAssociations that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetRouteServerAssociationsRequestT = Model::GetRouteServerAssociationsRequest>
  void GetRouteServerAssociationsAsync(const GetRouteServerAssociationsRequestT& request,
                                       const GetRouteServerAssociationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetRouteServerAssociations, request, handler, context);
  }

  /**
   * <p>Gets information about the route propagations for the specified route
   * server.</p> <p>When enabled, route server propagation installs the routes in the
   * FIB on the route table you've specified. Route server supports IPv4 and IPv6
   * route propagation.</p> <p>Amazon VPC Route Server simplifies routing for traffic
   * between workloads that are deployed within a VPC and its internet gateways. With
   * this feature, VPC Route Server dynamically updates VPC and internet gateway
   * route tables with your preferred IPv4 or IPv6 routes to achieve routing fault
   * tolerance for those workloads. This enables you to automatically reroute traffic
   * within a VPC, which increases the manageability of VPC routing and
   * interoperability with third-party workloads.</p> <p>Route server supports the
   * follow route table types:</p> <ul> <li> <p>VPC route tables not associated with
   * subnets</p> </li> <li> <p>Subnet route tables</p> </li> <li> <p>Internet gateway
   * route tables</p> </li> </ul> <p>Route server does not support route tables
   * associated with virtual private gateways. To propagate routes into a transit
   * gateway route table, use <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html">Transit
   * Gateway Connect</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetRouteServerPropagations">AWS
   * API Reference</a></p>
   */
  virtual Model::GetRouteServerPropagationsOutcome GetRouteServerPropagations(
      const Model::GetRouteServerPropagationsRequest& request) const;

  /**
   * A Callable wrapper for GetRouteServerPropagations that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetRouteServerPropagationsRequestT = Model::GetRouteServerPropagationsRequest>
  Model::GetRouteServerPropagationsOutcomeCallable GetRouteServerPropagationsCallable(
      const GetRouteServerPropagationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetRouteServerPropagations, request);
  }

  /**
   * An Async wrapper for GetRouteServerPropagations that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetRouteServerPropagationsRequestT = Model::GetRouteServerPropagationsRequest>
  void GetRouteServerPropagationsAsync(const GetRouteServerPropagationsRequestT& request,
                                       const GetRouteServerPropagationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetRouteServerPropagations, request, handler, context);
  }

  /**
   * <p>Gets the routing database for the specified route server. The <a
   * href="https://en.wikipedia.org/wiki/Routing_table">Routing Information Base
   * (RIB)</a> serves as a database that stores all the routing information and
   * network topology data collected by a router or routing system, such as routes
   * learned from BGP peers. The RIB is constantly updated as new routing information
   * is received or existing routes change. This ensures that the route server always
   * has the most current view of the network topology and can make optimal routing
   * decisions.</p> <p>Amazon VPC Route Server simplifies routing for traffic between
   * workloads that are deployed within a VPC and its internet gateways. With this
   * feature, VPC Route Server dynamically updates VPC and internet gateway route
   * tables with your preferred IPv4 or IPv6 routes to achieve routing fault
   * tolerance for those workloads. This enables you to automatically reroute traffic
   * within a VPC, which increases the manageability of VPC routing and
   * interoperability with third-party workloads.</p> <p>Route server supports the
   * follow route table types:</p> <ul> <li> <p>VPC route tables not associated with
   * subnets</p> </li> <li> <p>Subnet route tables</p> </li> <li> <p>Internet gateway
   * route tables</p> </li> </ul> <p>Route server does not support route tables
   * associated with virtual private gateways. To propagate routes into a transit
   * gateway route table, use <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html">Transit
   * Gateway Connect</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetRouteServerRoutingDatabase">AWS
   * API Reference</a></p>
   */
  virtual Model::GetRouteServerRoutingDatabaseOutcome GetRouteServerRoutingDatabase(
      const Model::GetRouteServerRoutingDatabaseRequest& request) const;

  /**
   * A Callable wrapper for GetRouteServerRoutingDatabase that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename GetRouteServerRoutingDatabaseRequestT = Model::GetRouteServerRoutingDatabaseRequest>
  Model::GetRouteServerRoutingDatabaseOutcomeCallable GetRouteServerRoutingDatabaseCallable(
      const GetRouteServerRoutingDatabaseRequestT& request) const {
    return SubmitCallable(&EC2Client::GetRouteServerRoutingDatabase, request);
  }

  /**
   * An Async wrapper for GetRouteServerRoutingDatabase that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetRouteServerRoutingDatabaseRequestT = Model::GetRouteServerRoutingDatabaseRequest>
  void GetRouteServerRoutingDatabaseAsync(const GetRouteServerRoutingDatabaseRequestT& request,
                                          const GetRouteServerRoutingDatabaseResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetRouteServerRoutingDatabase, request, handler, context);
  }

  /**
   * <p>Gets security groups that can be associated by the Amazon Web Services
   * account making the request with network interfaces in the specified
   * VPC.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSecurityGroupsForVpc">AWS
   * API Reference</a></p>
   */
  virtual Model::GetSecurityGroupsForVpcOutcome GetSecurityGroupsForVpc(const Model::GetSecurityGroupsForVpcRequest& request) const;

  /**
   * A Callable wrapper for GetSecurityGroupsForVpc that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename GetSecurityGroupsForVpcRequestT = Model::GetSecurityGroupsForVpcRequest>
  Model::GetSecurityGroupsForVpcOutcomeCallable GetSecurityGroupsForVpcCallable(const GetSecurityGroupsForVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::GetSecurityGroupsForVpc, request);
  }

  /**
   * An Async wrapper for GetSecurityGroupsForVpc that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename GetSecurityGroupsForVpcRequestT = Model::GetSecurityGroupsForVpcRequest>
  void GetSecurityGroupsForVpcAsync(const GetSecurityGroupsForVpcRequestT& request,
                                    const GetSecurityGroupsForVpcResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetSecurityGroupsForVpc, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configure-access-to-serial-console.html#serial-console-account-access">Manage
   * account access to the EC2 serial console</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSerialConsoleAccessStatus">AWS
   * API Reference</a></p>
   */
  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 <typename GetSerialConsoleAccessStatusRequestT = Model::GetSerialConsoleAccessStatusRequest>
  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 <typename GetSerialConsoleAccessStatusRequestT = Model::GetSerialConsoleAccessStatusRequest>
  void GetSerialConsoleAccessStatusAsync(const GetSerialConsoleAccessStatusResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetSerialConsoleAccessStatusRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetSerialConsoleAccessStatus, request, handler, context);
  }

  /**
   * <p>Gets the current state of <i>block public access for snapshots</i> setting
   * for the account and Region.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/block-public-access-snapshots.html">
   * Block public access for snapshots</a> in the <i>Amazon EBS User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSnapshotBlockPublicAccessState">AWS
   * API Reference</a></p>
   */
  virtual Model::GetSnapshotBlockPublicAccessStateOutcome GetSnapshotBlockPublicAccessState(
      const Model::GetSnapshotBlockPublicAccessStateRequest& request = {}) const;

  /**
   * A Callable wrapper for GetSnapshotBlockPublicAccessState that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GetSnapshotBlockPublicAccessStateRequestT = Model::GetSnapshotBlockPublicAccessStateRequest>
  Model::GetSnapshotBlockPublicAccessStateOutcomeCallable GetSnapshotBlockPublicAccessStateCallable(
      const GetSnapshotBlockPublicAccessStateRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetSnapshotBlockPublicAccessState, request);
  }

  /**
   * An Async wrapper for GetSnapshotBlockPublicAccessState that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename GetSnapshotBlockPublicAccessStateRequestT = Model::GetSnapshotBlockPublicAccessStateRequest>
  void GetSnapshotBlockPublicAccessStateAsync(const GetSnapshotBlockPublicAccessStateResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const GetSnapshotBlockPublicAccessStateRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetSnapshotBlockPublicAccessState, request, handler, context);
  }

  /**
   * <p>Calculates the Spot placement score for a Region or Availability Zone based
   * on the specified target capacity and compute requirements.</p> <p>You can
   * specify your compute requirements either by using
   * <code>InstanceRequirementsWithMetadata</code> and letting Amazon EC2 choose the
   * optimal instance types to fulfill your Spot request, or you can specify the
   * instance types by using <code>InstanceTypes</code>.</p> <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html">Spot
   * placement score</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSpotPlacementScores">AWS
   * API Reference</a></p>
   */
  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 <typename GetSpotPlacementScoresRequestT = Model::GetSpotPlacementScoresRequest>
  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 <typename GetSpotPlacementScoresRequestT = Model::GetSpotPlacementScoresRequest>
  void GetSpotPlacementScoresAsync(const GetSpotPlacementScoresRequestT& request,
                                   const GetSpotPlacementScoresResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetSpotPlacementScores, request, handler, context);
  }

  /**
   * <p>Gets information about the subnet CIDR reservations.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSubnetCidrReservations">AWS
   * API Reference</a></p>
   */
  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 <typename GetSubnetCidrReservationsRequestT = Model::GetSubnetCidrReservationsRequest>
  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 <typename GetSubnetCidrReservationsRequestT = Model::GetSubnetCidrReservationsRequest>
  void GetSubnetCidrReservationsAsync(const GetSubnetCidrReservationsRequestT& request,
                                      const GetSubnetCidrReservationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetSubnetCidrReservations, request, handler, context);
  }

  /**
   * <p>Lists the route tables to which the specified resource attachment propagates
   * routes.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayAttachmentPropagations">AWS
   * API Reference</a></p>
   */
  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 <typename GetTransitGatewayAttachmentPropagationsRequestT = Model::GetTransitGatewayAttachmentPropagationsRequest>
  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 <typename GetTransitGatewayAttachmentPropagationsRequestT = Model::GetTransitGatewayAttachmentPropagationsRequest>
  void GetTransitGatewayAttachmentPropagationsAsync(const GetTransitGatewayAttachmentPropagationsRequestT& request,
                                                    const GetTransitGatewayAttachmentPropagationsResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetTransitGatewayAttachmentPropagations, request, handler, context);
  }

  /**
   * <p>Retrieves the entries for a transit gateway metering policy.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayMeteringPolicyEntries">AWS
   * API Reference</a></p>
   */
  virtual Model::GetTransitGatewayMeteringPolicyEntriesOutcome GetTransitGatewayMeteringPolicyEntries(
      const Model::GetTransitGatewayMeteringPolicyEntriesRequest& request) const;

  /**
   * A Callable wrapper for GetTransitGatewayMeteringPolicyEntries that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename GetTransitGatewayMeteringPolicyEntriesRequestT = Model::GetTransitGatewayMeteringPolicyEntriesRequest>
  Model::GetTransitGatewayMeteringPolicyEntriesOutcomeCallable GetTransitGatewayMeteringPolicyEntriesCallable(
      const GetTransitGatewayMeteringPolicyEntriesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetTransitGatewayMeteringPolicyEntries, request);
  }

  /**
   * An Async wrapper for GetTransitGatewayMeteringPolicyEntries that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename GetTransitGatewayMeteringPolicyEntriesRequestT = Model::GetTransitGatewayMeteringPolicyEntriesRequest>
  void GetTransitGatewayMeteringPolicyEntriesAsync(const GetTransitGatewayMeteringPolicyEntriesRequestT& request,
                                                   const GetTransitGatewayMeteringPolicyEntriesResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetTransitGatewayMeteringPolicyEntries, request, handler, context);
  }

  /**
   * <p>Gets information about the associations for the transit gateway multicast
   * domain.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayMulticastDomainAssociations">AWS
   * API Reference</a></p>
   */
  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 <typename GetTransitGatewayMulticastDomainAssociationsRequestT = Model::GetTransitGatewayMulticastDomainAssociationsRequest>
  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 <typename GetTransitGatewayMulticastDomainAssociationsRequestT = Model::GetTransitGatewayMulticastDomainAssociationsRequest>
  void GetTransitGatewayMulticastDomainAssociationsAsync(
      const GetTransitGatewayMulticastDomainAssociationsRequestT& request,
      const GetTransitGatewayMulticastDomainAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetTransitGatewayMulticastDomainAssociations, request, handler, context);
  }

  /**
   * <p>Gets a list of the transit gateway policy table associations.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPolicyTableAssociations">AWS
   * API Reference</a></p>
   */
  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 <typename GetTransitGatewayPolicyTableAssociationsRequestT = Model::GetTransitGatewayPolicyTableAssociationsRequest>
  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 <typename GetTransitGatewayPolicyTableAssociationsRequestT = Model::GetTransitGatewayPolicyTableAssociationsRequest>
  void GetTransitGatewayPolicyTableAssociationsAsync(
      const GetTransitGatewayPolicyTableAssociationsRequestT& request,
      const GetTransitGatewayPolicyTableAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetTransitGatewayPolicyTableAssociations, request, handler, context);
  }

  /**
   * <p>Returns a list of transit gateway policy table entries.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPolicyTableEntries">AWS
   * API Reference</a></p>
   */
  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 <typename GetTransitGatewayPolicyTableEntriesRequestT = Model::GetTransitGatewayPolicyTableEntriesRequest>
  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 <typename GetTransitGatewayPolicyTableEntriesRequestT = Model::GetTransitGatewayPolicyTableEntriesRequest>
  void GetTransitGatewayPolicyTableEntriesAsync(const GetTransitGatewayPolicyTableEntriesRequestT& request,
                                                const GetTransitGatewayPolicyTableEntriesResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetTransitGatewayPolicyTableEntries, request, handler, context);
  }

  /**
   * <p>Gets information about the prefix list references in a specified transit
   * gateway route table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPrefixListReferences">AWS
   * API Reference</a></p>
   */
  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 <typename GetTransitGatewayPrefixListReferencesRequestT = Model::GetTransitGatewayPrefixListReferencesRequest>
  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 <typename GetTransitGatewayPrefixListReferencesRequestT = Model::GetTransitGatewayPrefixListReferencesRequest>
  void GetTransitGatewayPrefixListReferencesAsync(const GetTransitGatewayPrefixListReferencesRequestT& request,
                                                  const GetTransitGatewayPrefixListReferencesResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetTransitGatewayPrefixListReferences, request, handler, context);
  }

  /**
   * <p>Gets information about the associations for the specified transit gateway
   * route table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayRouteTableAssociations">AWS
   * API Reference</a></p>
   */
  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 <typename GetTransitGatewayRouteTableAssociationsRequestT = Model::GetTransitGatewayRouteTableAssociationsRequest>
  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 <typename GetTransitGatewayRouteTableAssociationsRequestT = Model::GetTransitGatewayRouteTableAssociationsRequest>
  void GetTransitGatewayRouteTableAssociationsAsync(const GetTransitGatewayRouteTableAssociationsRequestT& request,
                                                    const GetTransitGatewayRouteTableAssociationsResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetTransitGatewayRouteTableAssociations, request, handler, context);
  }

  /**
   * <p>Gets information about the route table propagations for the specified transit
   * gateway route table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayRouteTablePropagations">AWS
   * API Reference</a></p>
   */
  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 <typename GetTransitGatewayRouteTablePropagationsRequestT = Model::GetTransitGatewayRouteTablePropagationsRequest>
  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 <typename GetTransitGatewayRouteTablePropagationsRequestT = Model::GetTransitGatewayRouteTablePropagationsRequest>
  void GetTransitGatewayRouteTablePropagationsAsync(const GetTransitGatewayRouteTablePropagationsRequestT& request,
                                                    const GetTransitGatewayRouteTablePropagationsResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetTransitGatewayRouteTablePropagations, request, handler, context);
  }

  /**
   * <p>Get the Verified Access policy associated with the endpoint.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVerifiedAccessEndpointPolicy">AWS
   * API Reference</a></p>
   */
  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 <typename GetVerifiedAccessEndpointPolicyRequestT = Model::GetVerifiedAccessEndpointPolicyRequest>
  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 <typename GetVerifiedAccessEndpointPolicyRequestT = Model::GetVerifiedAccessEndpointPolicyRequest>
  void GetVerifiedAccessEndpointPolicyAsync(const GetVerifiedAccessEndpointPolicyRequestT& request,
                                            const GetVerifiedAccessEndpointPolicyResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetVerifiedAccessEndpointPolicy, request, handler, context);
  }

  /**
   * <p>Gets the targets for the specified network CIDR endpoint for Verified
   * Access.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVerifiedAccessEndpointTargets">AWS
   * API Reference</a></p>
   */
  virtual Model::GetVerifiedAccessEndpointTargetsOutcome GetVerifiedAccessEndpointTargets(
      const Model::GetVerifiedAccessEndpointTargetsRequest& request) const;

  /**
   * A Callable wrapper for GetVerifiedAccessEndpointTargets that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename GetVerifiedAccessEndpointTargetsRequestT = Model::GetVerifiedAccessEndpointTargetsRequest>
  Model::GetVerifiedAccessEndpointTargetsOutcomeCallable GetVerifiedAccessEndpointTargetsCallable(
      const GetVerifiedAccessEndpointTargetsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetVerifiedAccessEndpointTargets, request);
  }

  /**
   * An Async wrapper for GetVerifiedAccessEndpointTargets that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename GetVerifiedAccessEndpointTargetsRequestT = Model::GetVerifiedAccessEndpointTargetsRequest>
  void GetVerifiedAccessEndpointTargetsAsync(const GetVerifiedAccessEndpointTargetsRequestT& request,
                                             const GetVerifiedAccessEndpointTargetsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetVerifiedAccessEndpointTargets, request, handler, context);
  }

  /**
   * <p>Shows the contents of the Verified Access policy associated with the
   * group.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVerifiedAccessGroupPolicy">AWS
   * API Reference</a></p>
   */
  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 <typename GetVerifiedAccessGroupPolicyRequestT = Model::GetVerifiedAccessGroupPolicyRequest>
  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 <typename GetVerifiedAccessGroupPolicyRequestT = Model::GetVerifiedAccessGroupPolicyRequest>
  void GetVerifiedAccessGroupPolicyAsync(const GetVerifiedAccessGroupPolicyRequestT& request,
                                         const GetVerifiedAccessGroupPolicyResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetVerifiedAccessGroupPolicy, request, handler, context);
  }

  /**
   * <p>Gets information about resources in a VPC that are blocking encryption
   * enforcement.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html">Enforce
   * VPC encryption in transit</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpcResourcesBlockingEncryptionEnforcement">AWS
   * API Reference</a></p>
   */
  virtual Model::GetVpcResourcesBlockingEncryptionEnforcementOutcome GetVpcResourcesBlockingEncryptionEnforcement(
      const Model::GetVpcResourcesBlockingEncryptionEnforcementRequest& request) const;

  /**
   * A Callable wrapper for GetVpcResourcesBlockingEncryptionEnforcement that returns a future to the operation so that it can be executed
   * in parallel to other requests.
   */
  template <typename GetVpcResourcesBlockingEncryptionEnforcementRequestT = Model::GetVpcResourcesBlockingEncryptionEnforcementRequest>
  Model::GetVpcResourcesBlockingEncryptionEnforcementOutcomeCallable GetVpcResourcesBlockingEncryptionEnforcementCallable(
      const GetVpcResourcesBlockingEncryptionEnforcementRequestT& request) const {
    return SubmitCallable(&EC2Client::GetVpcResourcesBlockingEncryptionEnforcement, request);
  }

  /**
   * An Async wrapper for GetVpcResourcesBlockingEncryptionEnforcement that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  template <typename GetVpcResourcesBlockingEncryptionEnforcementRequestT = Model::GetVpcResourcesBlockingEncryptionEnforcementRequest>
  void GetVpcResourcesBlockingEncryptionEnforcementAsync(
      const GetVpcResourcesBlockingEncryptionEnforcementRequestT& request,
      const GetVpcResourcesBlockingEncryptionEnforcementResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetVpcResourcesBlockingEncryptionEnforcement, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnConnectionDeviceSampleConfiguration">AWS
   * API Reference</a></p>
   */
  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 <typename GetVpnConnectionDeviceSampleConfigurationRequestT = Model::GetVpnConnectionDeviceSampleConfigurationRequest>
  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 <typename GetVpnConnectionDeviceSampleConfigurationRequestT = Model::GetVpnConnectionDeviceSampleConfigurationRequest>
  void GetVpnConnectionDeviceSampleConfigurationAsync(
      const GetVpnConnectionDeviceSampleConfigurationRequestT& request,
      const GetVpnConnectionDeviceSampleConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetVpnConnectionDeviceSampleConfiguration, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/vpn/latest/s2svpn/your-cgw.html">Your customer
   * gateway device</a> in the <i>Amazon Web Services Site-to-Site VPN User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnConnectionDeviceTypes">AWS
   * API Reference</a></p>
   */
  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 <typename GetVpnConnectionDeviceTypesRequestT = Model::GetVpnConnectionDeviceTypesRequest>
  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 <typename GetVpnConnectionDeviceTypesRequestT = Model::GetVpnConnectionDeviceTypesRequest>
  void GetVpnConnectionDeviceTypesAsync(const GetVpnConnectionDeviceTypesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const GetVpnConnectionDeviceTypesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetVpnConnectionDeviceTypes, request, handler, context);
  }

  /**
   * <p>Get details of available tunnel endpoint maintenance.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnTunnelReplacementStatus">AWS
   * API Reference</a></p>
   */
  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 <typename GetVpnTunnelReplacementStatusRequestT = Model::GetVpnTunnelReplacementStatusRequest>
  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 <typename GetVpnTunnelReplacementStatusRequestT = Model::GetVpnTunnelReplacementStatusRequest>
  void GetVpnTunnelReplacementStatusAsync(const GetVpnTunnelReplacementStatusRequestT& request,
                                          const GetVpnTunnelReplacementStatusResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::GetVpnTunnelReplacementStatus, request, handler, context);
  }

  /**
   * <p>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.</p> <p>Uploading a client certificate
   * revocation list resets existing client connections.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportClientVpnClientCertificateRevocationList">AWS
   * API Reference</a></p>
   */
  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 <typename ImportClientVpnClientCertificateRevocationListRequestT = Model::ImportClientVpnClientCertificateRevocationListRequest>
  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 <typename ImportClientVpnClientCertificateRevocationListRequestT = Model::ImportClientVpnClientCertificateRevocationListRequest>
  void ImportClientVpnClientCertificateRevocationListAsync(
      const ImportClientVpnClientCertificateRevocationListRequestT& request,
      const ImportClientVpnClientCertificateRevocationListResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ImportClientVpnClientCertificateRevocationList, request, handler, context);
  }

  /**
   *  <p>To import your virtual machines (VMs) with a console-based experience,
   * you can use the <i>Import virtual machine images to Amazon Web Services</i>
   * template in the <a
   * href="https://console.aws.amazon.com/migrationhub/orchestrator">Migration Hub
   * Orchestrator console</a>. For more information, see the <a
   * href="https://docs.aws.amazon.com/migrationhub-orchestrator/latest/userguide/import-vm-images.html">
   * <i>Migration Hub Orchestrator User Guide</i> </a>.</p>  <p>Import single
   * or multi-volume disk images or EBS snapshots into an Amazon Machine Image
   * (AMI).</p>  <p>Amazon Web Services VM Import/Export strongly
   * recommends specifying a value for either the <code>--license-type</code> or
   * <code>--usage-operation</code> parameter when you create a new VM Import task.
   * This ensures your operating system is licensed appropriately and your billing is
   * optimized.</p>  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-image-import.html">Importing
   * a VM as an image using VM Import/Export</a> in the <i>VM Import/Export User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportImage">AWS API
   * Reference</a></p>
   */
  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 <typename ImportImageRequestT = Model::ImportImageRequest>
  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 <typename ImportImageRequestT = Model::ImportImageRequest>
  void ImportImageAsync(const ImportImageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ImportImageRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ImportImage, request, handler, context);
  }

  /**
   *  <p>We recommend that you use the <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportImage.html">
   * <code>ImportImage</code> </a> API instead. For more information, see <a
   * href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-image-import.html">Importing
   * a VM as an image using VM Import/Export</a> in the <i>VM Import/Export User
   * Guide</i>.</p>  <p>Creates an import instance task using metadata from
   * the specified disk image.</p> <p>This API action supports only single-volume
   * VMs. To import multi-volume VMs, use <a>ImportImage</a> instead.</p> <p>For
   * information about the import manifest referenced by this API action, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM
   * Import Manifest</a>.</p> <p>This API action is not supported by the Command Line
   * Interface (CLI).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportInstance">AWS
   * API Reference</a></p>
   */
  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 <typename ImportInstanceRequestT = Model::ImportInstanceRequest>
  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 <typename ImportInstanceRequestT = Model::ImportInstanceRequest>
  void ImportInstanceAsync(const ImportInstanceRequestT& request, const ImportInstanceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ImportInstance, request, handler, context);
  }

  /**
   * <p>Imports the public key from an RSA or ED25519 key pair that you created using
   * a third-party tool. You give Amazon Web Services only the public key. The
   * private key is never transferred between you and Amazon Web Services.</p> <p>For
   * more information about the requirements for importing a key pair, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-key-pairs.html#how-to-generate-your-own-key-and-import-it-to-aws">Create
   * a key pair and import the public key to Amazon EC2</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportKeyPair">AWS
   * API Reference</a></p>
   */
  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 <typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
  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 <typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
  void ImportKeyPairAsync(const ImportKeyPairRequestT& request, const ImportKeyPairResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ImportKeyPair, request, handler, context);
  }

  /**
   * <p>Imports a disk into an EBS snapshot.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-import-snapshot.html">Importing
   * a disk as a snapshot using VM Import/Export</a> in the <i>VM Import/Export User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportSnapshot">AWS
   * API Reference</a></p>
   */
  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 <typename ImportSnapshotRequestT = Model::ImportSnapshotRequest>
  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 <typename ImportSnapshotRequestT = Model::ImportSnapshotRequest>
  void ImportSnapshotAsync(const ImportSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ImportSnapshotRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ImportSnapshot, request, handler, context);
  }

  /**
   *  <p>This API action supports only single-volume VMs. To import
   * multi-volume VMs, use <a>ImportImage</a> instead. To import a disk to a
   * snapshot, use <a>ImportSnapshot</a> instead.</p>  <p>Creates an import
   * volume task using metadata from the specified disk image.</p> <p>For information
   * about the import manifest referenced by this API action, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM
   * Import Manifest</a>.</p> <p>This API action is not supported by the Command Line
   * Interface (CLI).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportVolume">AWS
   * API Reference</a></p>
   */
  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 <typename ImportVolumeRequestT = Model::ImportVolumeRequest>
  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 <typename ImportVolumeRequestT = Model::ImportVolumeRequest>
  void ImportVolumeAsync(const ImportVolumeRequestT& request, const ImportVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ImportVolume, request, handler, context);
  }

  /**
   * <p>Lists one or more AMIs that are currently in the Recycle Bin. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin.html">Recycle
   * Bin</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ListImagesInRecycleBin">AWS
   * API Reference</a></p>
   */
  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 <typename ListImagesInRecycleBinRequestT = Model::ListImagesInRecycleBinRequest>
  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 <typename ListImagesInRecycleBinRequestT = Model::ListImagesInRecycleBinRequest>
  void ListImagesInRecycleBinAsync(const ListImagesInRecycleBinResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListImagesInRecycleBinRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ListImagesInRecycleBin, request, handler, context);
  }

  /**
   * <p>Lists one or more snapshots that are currently in the Recycle
   * Bin.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ListSnapshotsInRecycleBin">AWS
   * API Reference</a></p>
   */
  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 <typename ListSnapshotsInRecycleBinRequestT = Model::ListSnapshotsInRecycleBinRequest>
  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 <typename ListSnapshotsInRecycleBinRequestT = Model::ListSnapshotsInRecycleBinRequest>
  void ListSnapshotsInRecycleBinAsync(const ListSnapshotsInRecycleBinResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListSnapshotsInRecycleBinRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ListSnapshotsInRecycleBin, request, handler, context);
  }

  /**
   * <p>Lists one or more volumes that are currently in the Recycle
   * Bin.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ListVolumesInRecycleBin">AWS
   * API Reference</a></p>
   */
  virtual Model::ListVolumesInRecycleBinOutcome ListVolumesInRecycleBin(const Model::ListVolumesInRecycleBinRequest& request = {}) const;

  /**
   * A Callable wrapper for ListVolumesInRecycleBin that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ListVolumesInRecycleBinRequestT = Model::ListVolumesInRecycleBinRequest>
  Model::ListVolumesInRecycleBinOutcomeCallable ListVolumesInRecycleBinCallable(const ListVolumesInRecycleBinRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ListVolumesInRecycleBin, request);
  }

  /**
   * An Async wrapper for ListVolumesInRecycleBin that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ListVolumesInRecycleBinRequestT = Model::ListVolumesInRecycleBinRequest>
  void ListVolumesInRecycleBinAsync(const ListVolumesInRecycleBinResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListVolumesInRecycleBinRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ListVolumesInRecycleBin, request, handler, context);
  }

  /**
   * <p>Locks an Amazon EBS snapshot in either <i>governance</i> or <i>compliance</i>
   * mode to protect it against accidental or malicious deletions for a specific
   * duration. A locked snapshot can't be deleted.</p> <p>You can also use this
   * action to modify the lock settings for a snapshot that is already locked. The
   * allowed modifications depend on the lock mode and lock state:</p> <ul> <li>
   * <p>If the snapshot is locked in governance mode, you can modify the lock mode
   * and the lock duration or lock expiration date.</p> </li> <li> <p>If the snapshot
   * is locked in compliance mode and it is in the cooling-off period, you can modify
   * the lock mode and the lock duration or lock expiration date.</p> </li> <li>
   * <p>If the snapshot is locked in compliance mode and the cooling-off period has
   * lapsed, you can only increase the lock duration or extend the lock expiration
   * date.</p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/LockSnapshot">AWS
   * API Reference</a></p>
   */
  virtual Model::LockSnapshotOutcome LockSnapshot(const Model::LockSnapshotRequest& request) const;

  /**
   * A Callable wrapper for LockSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename LockSnapshotRequestT = Model::LockSnapshotRequest>
  Model::LockSnapshotOutcomeCallable LockSnapshotCallable(const LockSnapshotRequestT& request) const {
    return SubmitCallable(&EC2Client::LockSnapshot, request);
  }

  /**
   * An Async wrapper for LockSnapshot that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename LockSnapshotRequestT = Model::LockSnapshotRequest>
  void LockSnapshotAsync(const LockSnapshotRequestT& request, const LockSnapshotResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::LockSnapshot, request, handler, context);
  }

  /**
   * <p>Modifies an attribute of the specified Elastic IP address. For requirements,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html#Using_Elastic_Addressing_Reverse_DNS">Using
   * reverse DNS for email applications</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyAddressAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyAddressAttributeRequestT = Model::ModifyAddressAttributeRequest>
  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 <typename ModifyAddressAttributeRequestT = Model::ModifyAddressAttributeRequest>
  void ModifyAddressAttributeAsync(const ModifyAddressAttributeRequestT& request,
                                   const ModifyAddressAttributeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyAddressAttribute, request, handler, context);
  }

  /**
   * <p>Changes the opt-in status of the specified zone group for your
   * account.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyAvailabilityZoneGroup">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyAvailabilityZoneGroupRequestT = Model::ModifyAvailabilityZoneGroupRequest>
  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 <typename ModifyAvailabilityZoneGroupRequestT = Model::ModifyAvailabilityZoneGroupRequest>
  void ModifyAvailabilityZoneGroupAsync(const ModifyAvailabilityZoneGroupRequestT& request,
                                        const ModifyAvailabilityZoneGroupResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyAvailabilityZoneGroup, request, handler, context);
  }

  /**
   * <p>Modifies a Capacity Reservation's capacity, instance eligibility, and the
   * conditions under which it is to be released. You can't modify a Capacity
   * Reservation's instance type, EBS optimization, platform, instance store
   * settings, Availability Zone, or tenancy. 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. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/capacity-reservations-modify.html">
   * Modify an active Capacity Reservation</a>.</p> <p>The allowed modifications
   * depend on the state of the Capacity Reservation:</p> <ul> <li> <p>
   * <code>assessing</code> or <code>scheduled</code> state - You can modify the tags
   * only.</p> </li> <li> <p> <code>pending</code> state - You can't modify the
   * Capacity Reservation in any way.</p> </li> <li> <p> <code>active</code> state
   * but still within the commitment duration - You can't decrease the instance count
   * or set an end date that is within the commitment duration. All other
   * modifications are allowed.</p> </li> <li> <p> <code>active</code> state with no
   * commitment duration or elapsed commitment duration - All modifications are
   * allowed.</p> </li> <li> <p> <code>expired</code>, <code>cancelled</code>,
   * <code>unsupported</code>, or <code>failed</code> state - You can't modify the
   * Capacity Reservation in any way.</p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyCapacityReservation">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyCapacityReservationRequestT = Model::ModifyCapacityReservationRequest>
  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 <typename ModifyCapacityReservationRequestT = Model::ModifyCapacityReservationRequest>
  void ModifyCapacityReservationAsync(const ModifyCapacityReservationRequestT& request,
                                      const ModifyCapacityReservationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyCapacityReservation, request, handler, context);
  }

  /**
   * <p>Modifies a Capacity Reservation Fleet.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyCapacityReservationFleet">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyCapacityReservationFleetRequestT = Model::ModifyCapacityReservationFleetRequest>
  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 <typename ModifyCapacityReservationFleetRequestT = Model::ModifyCapacityReservationFleetRequest>
  void ModifyCapacityReservationFleetAsync(const ModifyCapacityReservationFleetRequestT& request,
                                           const ModifyCapacityReservationFleetResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyCapacityReservationFleet, request, handler, context);
  }

  /**
   * <p>Modifies the specified Client VPN endpoint. Modifying the DNS server resets
   * existing client connections.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyClientVpnEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyClientVpnEndpointRequestT = Model::ModifyClientVpnEndpointRequest>
  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 <typename ModifyClientVpnEndpointRequestT = Model::ModifyClientVpnEndpointRequest>
  void ModifyClientVpnEndpointAsync(const ModifyClientVpnEndpointRequestT& request,
                                    const ModifyClientVpnEndpointResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyClientVpnEndpoint, request, handler, context);
  }

  /**
   * <p>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.</p>
   * <p> <code>ModifyDefaultCreditSpecification</code> 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 <code>GetDefaultCreditSpecification</code> and check
   * <code>DefaultCreditSpecification</code> for updates.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html">Burstable
   * performance instances</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyDefaultCreditSpecification">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyDefaultCreditSpecificationRequestT = Model::ModifyDefaultCreditSpecificationRequest>
  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 <typename ModifyDefaultCreditSpecificationRequestT = Model::ModifyDefaultCreditSpecificationRequest>
  void ModifyDefaultCreditSpecificationAsync(const ModifyDefaultCreditSpecificationRequestT& request,
                                             const ModifyDefaultCreditSpecificationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyDefaultCreditSpecification, request, handler, context);
  }

  /**
   * <p>Changes the default KMS key for EBS encryption by default for your account in
   * this Region.</p> <p>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. Amazon EBS does not support
   * asymmetric KMS keys.</p> <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html">Amazon
   * EBS encryption</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyEbsDefaultKmsKeyId">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyEbsDefaultKmsKeyIdRequestT = Model::ModifyEbsDefaultKmsKeyIdRequest>
  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 <typename ModifyEbsDefaultKmsKeyIdRequestT = Model::ModifyEbsDefaultKmsKeyIdRequest>
  void ModifyEbsDefaultKmsKeyIdAsync(const ModifyEbsDefaultKmsKeyIdRequestT& request,
                                     const ModifyEbsDefaultKmsKeyIdResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyEbsDefaultKmsKeyId, request, handler, context);
  }

  /**
   * <p>Modifies the specified EC2 Fleet.</p> <p>You can only modify an EC2 Fleet
   * request of type <code>maintain</code>.</p> <p>While the EC2 Fleet is being
   * modified, it is in the <code>modifying</code> state.</p> <p>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 <code>lowest-price</code>, the EC2 Fleet launches
   * instances using the Spot Instance pool with the lowest price. If the allocation
   * strategy is <code>diversified</code>, the EC2 Fleet distributes the instances
   * across the Spot Instance pools. If the allocation strategy is
   * <code>capacity-optimized</code>, EC2 Fleet launches instances from Spot Instance
   * pools with optimal capacity for the number of instances that are launching.</p>
   * <p>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
   * <code>lowest-price</code>, the EC2 Fleet terminates the instances with the
   * highest price per unit. If the allocation strategy is
   * <code>capacity-optimized</code>, the EC2 Fleet terminates the instances in the
   * Spot Instance pools that have the least available Spot Instance capacity. If the
   * allocation strategy is <code>diversified</code>, 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.</p> <p>If you are
   * finished with your EC2 Fleet for now, but will use it again later, you can set
   * the target capacity to 0.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyFleet">AWS API
   * Reference</a></p>
   */
  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 <typename ModifyFleetRequestT = Model::ModifyFleetRequest>
  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 <typename ModifyFleetRequestT = Model::ModifyFleetRequest>
  void ModifyFleetAsync(const ModifyFleetRequestT& request, const ModifyFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyFleet, request, handler, context);
  }

  /**
   * <p>Modifies the specified attribute of the specified Amazon FPGA Image
   * (AFI).</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyFpgaImageAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyFpgaImageAttributeRequestT = Model::ModifyFpgaImageAttributeRequest>
  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 <typename ModifyFpgaImageAttributeRequestT = Model::ModifyFpgaImageAttributeRequest>
  void ModifyFpgaImageAttributeAsync(const ModifyFpgaImageAttributeRequestT& request,
                                     const ModifyFpgaImageAttributeResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyFpgaImageAttribute, request, handler, context);
  }

  /**
   * <p>Modify the auto-placement setting of a Dedicated Host. When auto-placement is
   * enabled, any instances that you launch with a tenancy of <code>host</code> 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.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyHosts">AWS API
   * Reference</a></p>
   */
  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 <typename ModifyHostsRequestT = Model::ModifyHostsRequest>
  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 <typename ModifyHostsRequestT = Model::ModifyHostsRequest>
  void ModifyHostsAsync(const ModifyHostsRequestT& request, const ModifyHostsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyHosts, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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: <code>bundle</code> |
   * <code>conversion-task</code> | <code>customer-gateway</code> |
   * <code>dhcp-options</code> | <code>elastic-ip-allocation</code> |
   * <code>elastic-ip-association</code> | <code>export-task</code> |
   * <code>flow-log</code> | <code>image</code> | <code>import-task</code> |
   * <code>internet-gateway</code> | <code>network-acl</code> |
   * <code>network-acl-association</code> | <code>network-interface</code> |
   * <code>network-interface-attachment</code> | <code>prefix-list</code> |
   * <code>route-table</code> | <code>route-table-association</code> |
   * <code>security-group</code> | <code>subnet</code> |
   * <code>subnet-cidr-block-association</code> | <code>vpc</code> |
   * <code>vpc-cidr-block-association</code> | <code>vpc-endpoint</code> |
   * <code>vpc-peering-connection</code> | <code>vpn-connection</code> |
   * <code>vpn-gateway</code>.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/resource-ids.html">Resource
   * IDs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p> <p>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
   * <code>Describe</code> command for the resource type.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIdFormat">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyIdFormatRequestT = Model::ModifyIdFormatRequest>
  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 <typename ModifyIdFormatRequestT = Model::ModifyIdFormatRequest>
  void ModifyIdFormatAsync(const ModifyIdFormatRequestT& request, const ModifyIdFormatResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIdFormat, request, handler, context);
  }

  /**
   * <p>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. </p> <p>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: <code>bundle</code>
   * | <code>conversion-task</code> | <code>customer-gateway</code> |
   * <code>dhcp-options</code> | <code>elastic-ip-allocation</code> |
   * <code>elastic-ip-association</code> | <code>export-task</code> |
   * <code>flow-log</code> | <code>image</code> | <code>import-task</code> |
   * <code>internet-gateway</code> | <code>network-acl</code> |
   * <code>network-acl-association</code> | <code>network-interface</code> |
   * <code>network-interface-attachment</code> | <code>prefix-list</code> |
   * <code>route-table</code> | <code>route-table-association</code> |
   * <code>security-group</code> | <code>subnet</code> |
   * <code>subnet-cidr-block-association</code> | <code>vpc</code> |
   * <code>vpc-cidr-block-association</code> | <code>vpc-endpoint</code> |
   * <code>vpc-peering-connection</code> | <code>vpn-connection</code> |
   * <code>vpn-gateway</code>. </p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/resource-ids.html">Resource
   * IDs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. </p> <p>This
   * setting applies to the principal specified in the request; it does not apply to
   * the principal that makes the request. </p> <p>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 <code>Describe</code>
   * command for the resource type.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIdentityIdFormat">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyIdentityIdFormatRequestT = Model::ModifyIdentityIdFormatRequest>
  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 <typename ModifyIdentityIdFormatRequestT = Model::ModifyIdentityIdFormatRequest>
  void ModifyIdentityIdFormatAsync(const ModifyIdentityIdFormatRequestT& request,
                                   const ModifyIdentityIdFormatResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIdentityIdFormat, request, handler, context);
  }

  /**
   * <p>Modifies the specified attribute of the specified AMI. You can specify only
   * one attribute at a time.</p> <p>To specify the attribute, you can use the
   * <code>Attribute</code> parameter, or one of the following parameters:
   * <code>Description</code>, <code>ImdsSupport</code>, or
   * <code>LaunchPermission</code>.</p> <p>Images with an Amazon Web Services
   * Marketplace product code cannot be made public.</p> <p>To enable the
   * SriovNetSupport enhanced networking attribute of an image, enable
   * SriovNetSupport on an instance and create an AMI from the
   * instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyImageAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyImageAttributeRequestT = Model::ModifyImageAttributeRequest>
  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 <typename ModifyImageAttributeRequestT = Model::ModifyImageAttributeRequest>
  void ModifyImageAttributeAsync(const ModifyImageAttributeRequestT& request, const ModifyImageAttributeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyImageAttribute, request, handler, context);
  }

  /**
   * <p>Modifies the specified attribute of the specified instance. You can specify
   * only one attribute at a time.</p> <p> <b>Note: </b>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
   * <a>ModifyNetworkInterfaceAttribute</a> action.</p> <p>To modify some attributes,
   * the instance must be stopped. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_ChangingAttributesWhileInstanceStopped.html">Modify
   * a stopped instance</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyInstanceAttributeRequestT = Model::ModifyInstanceAttributeRequest>
  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 <typename ModifyInstanceAttributeRequestT = Model::ModifyInstanceAttributeRequest>
  void ModifyInstanceAttributeAsync(const ModifyInstanceAttributeRequestT& request,
                                    const ModifyInstanceAttributeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceAttribute, request, handler, context);
  }

  /**
   * <p>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 <code>open</code> Capacity Reservation with matching attributes, run in
   * On-Demand Instance capacity, or only run in a Capacity
   * Reservation.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceCapacityReservationAttributes">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyInstanceCapacityReservationAttributesRequestT = Model::ModifyInstanceCapacityReservationAttributesRequest>
  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 <typename ModifyInstanceCapacityReservationAttributesRequestT = Model::ModifyInstanceCapacityReservationAttributesRequest>
  void ModifyInstanceCapacityReservationAttributesAsync(
      const ModifyInstanceCapacityReservationAttributesRequestT& request,
      const ModifyInstanceCapacityReservationAttributesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceCapacityReservationAttributes, request, handler, context);
  }

  /**
   * <p>Modifies the specified EC2 Instance Connect Endpoint.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/modify-ec2-instance-connect-endpoint.html">Modify
   * an EC2 Instance Connect Endpoint</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceConnectEndpoint">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyInstanceConnectEndpointOutcome ModifyInstanceConnectEndpoint(
      const Model::ModifyInstanceConnectEndpointRequest& request) const;

  /**
   * A Callable wrapper for ModifyInstanceConnectEndpoint that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ModifyInstanceConnectEndpointRequestT = Model::ModifyInstanceConnectEndpointRequest>
  Model::ModifyInstanceConnectEndpointOutcomeCallable ModifyInstanceConnectEndpointCallable(
      const ModifyInstanceConnectEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceConnectEndpoint, request);
  }

  /**
   * An Async wrapper for ModifyInstanceConnectEndpoint that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ModifyInstanceConnectEndpointRequestT = Model::ModifyInstanceConnectEndpointRequest>
  void ModifyInstanceConnectEndpointAsync(const ModifyInstanceConnectEndpointRequestT& request,
                                          const ModifyInstanceConnectEndpointResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceConnectEndpoint, request, handler, context);
  }

  /**
   * <p>By default, all vCPUs for the instance type are active when you launch an
   * instance. When you configure the number of active vCPUs for the instance, it can
   * help you save on licensing costs and optimize performance. The base cost of the
   * instance remains unchanged.</p> <p>The number of active vCPUs equals the number
   * of threads per CPU core multiplied by the number of cores. The instance must be
   * in a <code>Stopped</code> state before you make changes.</p>  <p>Some
   * instance type options do not support this capability. For more information, see
   * <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cpu-options-supported-instances-values.html">Supported
   * CPU options</a> in the <i>Amazon EC2 User Guide</i>.</p> <p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceCpuOptions">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyInstanceCpuOptionsOutcome ModifyInstanceCpuOptions(const Model::ModifyInstanceCpuOptionsRequest& request) const;

  /**
   * A Callable wrapper for ModifyInstanceCpuOptions that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ModifyInstanceCpuOptionsRequestT = Model::ModifyInstanceCpuOptionsRequest>
  Model::ModifyInstanceCpuOptionsOutcomeCallable ModifyInstanceCpuOptionsCallable(const ModifyInstanceCpuOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceCpuOptions, request);
  }

  /**
   * An Async wrapper for ModifyInstanceCpuOptions that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ModifyInstanceCpuOptionsRequestT = Model::ModifyInstanceCpuOptionsRequest>
  void ModifyInstanceCpuOptionsAsync(const ModifyInstanceCpuOptionsRequestT& request,
                                     const ModifyInstanceCpuOptionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceCpuOptions, request, handler, context);
  }

  /**
   * <p>Modifies the credit option for CPU usage on a running or stopped burstable
   * performance instance. The credit options are <code>standard</code> and
   * <code>unlimited</code>.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html">Burstable
   * performance instances</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceCreditSpecification">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyInstanceCreditSpecificationRequestT = Model::ModifyInstanceCreditSpecificationRequest>
  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 <typename ModifyInstanceCreditSpecificationRequestT = Model::ModifyInstanceCreditSpecificationRequest>
  void ModifyInstanceCreditSpecificationAsync(const ModifyInstanceCreditSpecificationRequestT& request,
                                              const ModifyInstanceCreditSpecificationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceCreditSpecification, request, handler, context);
  }

  /**
   * <p>Modifies the start time for a scheduled Amazon EC2 instance
   * event.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceEventStartTime">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyInstanceEventStartTimeRequestT = Model::ModifyInstanceEventStartTimeRequest>
  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 <typename ModifyInstanceEventStartTimeRequestT = Model::ModifyInstanceEventStartTimeRequest>
  void ModifyInstanceEventStartTimeAsync(const ModifyInstanceEventStartTimeRequestT& request,
                                         const ModifyInstanceEventStartTimeResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceEventStartTime, request, handler, context);
  }

  /**
   * <p>Modifies the specified event window.</p> <p>You can define either a set of
   * time ranges or a cron expression when modifying the event window, but not
   * both.</p> <p>To modify the targets associated with the event window, use the
   * <a>AssociateInstanceEventWindow</a> and <a>DisassociateInstanceEventWindow</a>
   * API.</p> <p>If Amazon Web Services has already scheduled an event, modifying an
   * event window won't change the time of the scheduled event.</p> <p>For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
   * event windows for scheduled events</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceEventWindow">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyInstanceEventWindowRequestT = Model::ModifyInstanceEventWindowRequest>
  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 <typename ModifyInstanceEventWindowRequestT = Model::ModifyInstanceEventWindowRequest>
  void ModifyInstanceEventWindowAsync(const ModifyInstanceEventWindowRequestT& request,
                                      const ModifyInstanceEventWindowResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceEventWindow, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-recover.html#instance-configuration-recovery">Simplified
   * automatic recovery</a>.</p> <p>Modifies the reboot migration behavior during a
   * user-initiated reboot of an instance that has a pending
   * <code>system-reboot</code> event. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/schedevents_actions_reboot.html#reboot-migration">Enable
   * or disable reboot migration</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceMaintenanceOptions">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyInstanceMaintenanceOptionsRequestT = Model::ModifyInstanceMaintenanceOptionsRequest>
  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 <typename ModifyInstanceMaintenanceOptionsRequestT = Model::ModifyInstanceMaintenanceOptionsRequest>
  void ModifyInstanceMaintenanceOptionsAsync(const ModifyInstanceMaintenanceOptionsRequestT& request,
                                             const ModifyInstanceMaintenanceOptionsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceMaintenanceOptions, request, handler, context);
  }

  /**
   * <p>Modifies the default instance metadata service (IMDS) settings at the account
   * level in the specified Amazon Web Services&#x2028; Region.</p>  <p>To
   * remove a parameter's account-level default setting, specify
   * <code>no-preference</code>. If an account-level setting is cleared with
   * <code>no-preference</code>, then the instance launch considers the other
   * instance metadata settings. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-options.html#instance-metadata-options-order-of-precedence">Order
   * of precedence for instance metadata options</a> in the <i>Amazon EC2 User
   * Guide</i>.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceMetadataDefaults">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyInstanceMetadataDefaultsOutcome ModifyInstanceMetadataDefaults(
      const Model::ModifyInstanceMetadataDefaultsRequest& request = {}) const;

  /**
   * A Callable wrapper for ModifyInstanceMetadataDefaults that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ModifyInstanceMetadataDefaultsRequestT = Model::ModifyInstanceMetadataDefaultsRequest>
  Model::ModifyInstanceMetadataDefaultsOutcomeCallable ModifyInstanceMetadataDefaultsCallable(
      const ModifyInstanceMetadataDefaultsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ModifyInstanceMetadataDefaults, request);
  }

  /**
   * An Async wrapper for ModifyInstanceMetadataDefaults that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename ModifyInstanceMetadataDefaultsRequestT = Model::ModifyInstanceMetadataDefaultsRequest>
  void ModifyInstanceMetadataDefaultsAsync(const ModifyInstanceMetadataDefaultsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ModifyInstanceMetadataDefaultsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ModifyInstanceMetadataDefaults, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html">Instance
   * metadata and user data</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceMetadataOptions">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyInstanceMetadataOptionsRequestT = Model::ModifyInstanceMetadataOptionsRequest>
  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 <typename ModifyInstanceMetadataOptionsRequestT = Model::ModifyInstanceMetadataOptionsRequest>
  void ModifyInstanceMetadataOptionsAsync(const ModifyInstanceMetadataOptionsRequestT& request,
                                          const ModifyInstanceMetadataOptionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceMetadataOptions, request, handler, context);
  }

  /**
   * <p>Change the configuration of the network performance options for an existing
   * instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceNetworkPerformanceOptions">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyInstanceNetworkPerformanceOptionsOutcome ModifyInstanceNetworkPerformanceOptions(
      const Model::ModifyInstanceNetworkPerformanceOptionsRequest& request) const;

  /**
   * A Callable wrapper for ModifyInstanceNetworkPerformanceOptions that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename ModifyInstanceNetworkPerformanceOptionsRequestT = Model::ModifyInstanceNetworkPerformanceOptionsRequest>
  Model::ModifyInstanceNetworkPerformanceOptionsOutcomeCallable ModifyInstanceNetworkPerformanceOptionsCallable(
      const ModifyInstanceNetworkPerformanceOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceNetworkPerformanceOptions, request);
  }

  /**
   * An Async wrapper for ModifyInstanceNetworkPerformanceOptions that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename ModifyInstanceNetworkPerformanceOptionsRequestT = Model::ModifyInstanceNetworkPerformanceOptionsRequest>
  void ModifyInstanceNetworkPerformanceOptionsAsync(const ModifyInstanceNetworkPerformanceOptionsRequestT& request,
                                                    const ModifyInstanceNetworkPerformanceOptionsResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstanceNetworkPerformanceOptions, request, handler, context);
  }

  /**
   * <p>Modifies the placement attributes for a specified instance. You can do the
   * following:</p> <ul> <li> <p>Modify the affinity between an instance and a <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-overview.html">Dedicated
   * Host</a>. When affinity is set to <code>host</code> and the instance is not
   * associated with a specific Dedicated Host, the next time the instance is
   * started, it is automatically associated with the host on which it lands. If the
   * instance is restarted or rebooted, this relationship persists.</p> </li> <li>
   * <p>Change the Dedicated Host with which an instance is associated.</p> </li>
   * <li> <p>Change the instance tenancy of an instance.</p> </li> <li> <p>Move an
   * instance to or from a <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">placement
   * group</a>.</p> </li> </ul> <p>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.</p> <p>To modify the host ID,
   * tenancy, placement group, or partition for an instance, the instance must be in
   * the <code>stopped</code> state.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstancePlacement">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyInstancePlacementRequestT = Model::ModifyInstancePlacementRequest>
  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 <typename ModifyInstancePlacementRequestT = Model::ModifyInstancePlacementRequest>
  void ModifyInstancePlacementAsync(const ModifyInstancePlacementRequestT& request,
                                    const ModifyInstancePlacementResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyInstancePlacement, request, handler, context);
  }

  /**
   * <p>Modify the configurations of an IPAM. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpam">AWS API
   * Reference</a></p>
   */
  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 <typename ModifyIpamRequestT = Model::ModifyIpamRequest>
  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 <typename ModifyIpamRequestT = Model::ModifyIpamRequest>
  void ModifyIpamAsync(const ModifyIpamRequestT& request, const ModifyIpamResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIpam, request, handler, context);
  }

  /**
   * <p>Modifies the allocation rules in an IPAM policy.</p> <p>An IPAM policy is a
   * set of rules that define how public IPv4 addresses from IPAM pools are allocated
   * to Amazon Web Services resources. Each rule maps an Amazon Web Services service
   * to IPAM pools that the service will use to get IP addresses. A single policy can
   * have multiple rules and be applied to multiple Amazon Web Services Regions. If
   * the IPAM pool run out of addresses then the services fallback to Amazon-provided
   * IP addresses. A policy can be applied to an individual Amazon Web Services
   * account or an entity within Amazon Web Services Organizations.</p> <p>Allocation
   * rules are optional configurations within an IPAM policy that map Amazon Web
   * Services resource types to specific IPAM pools. If no rules are defined, the
   * resource types default to using Amazon-provided IP addresses.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamPolicyAllocationRules">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyIpamPolicyAllocationRulesOutcome ModifyIpamPolicyAllocationRules(
      const Model::ModifyIpamPolicyAllocationRulesRequest& request) const;

  /**
   * A Callable wrapper for ModifyIpamPolicyAllocationRules that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ModifyIpamPolicyAllocationRulesRequestT = Model::ModifyIpamPolicyAllocationRulesRequest>
  Model::ModifyIpamPolicyAllocationRulesOutcomeCallable ModifyIpamPolicyAllocationRulesCallable(
      const ModifyIpamPolicyAllocationRulesRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamPolicyAllocationRules, request);
  }

  /**
   * An Async wrapper for ModifyIpamPolicyAllocationRules that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename ModifyIpamPolicyAllocationRulesRequestT = Model::ModifyIpamPolicyAllocationRulesRequest>
  void ModifyIpamPolicyAllocationRulesAsync(const ModifyIpamPolicyAllocationRulesRequestT& request,
                                            const ModifyIpamPolicyAllocationRulesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIpamPolicyAllocationRules, request, handler, context);
  }

  /**
   * <p>Modify the configurations of an IPAM pool.</p> <p>For more information, see
   * <a href="https://docs.aws.amazon.com/vpc/latest/ipam/mod-pool-ipam.html">Modify
   * a pool</a> in the <i>Amazon VPC IPAM User Guide</i>. </p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamPool">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyIpamPoolRequestT = Model::ModifyIpamPoolRequest>
  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 <typename ModifyIpamPoolRequestT = Model::ModifyIpamPoolRequest>
  void ModifyIpamPoolAsync(const ModifyIpamPoolRequestT& request, const ModifyIpamPoolResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIpamPool, request, handler, context);
  }

  /**
   * <p>Modifies an IPAM prefix list resolver. You can update the description and
   * CIDR selection rules. Changes to rules will trigger re-evaluation and potential
   * updates to associated prefix lists.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamPrefixListResolver">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyIpamPrefixListResolverOutcome ModifyIpamPrefixListResolver(
      const Model::ModifyIpamPrefixListResolverRequest& request) const;

  /**
   * A Callable wrapper for ModifyIpamPrefixListResolver that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ModifyIpamPrefixListResolverRequestT = Model::ModifyIpamPrefixListResolverRequest>
  Model::ModifyIpamPrefixListResolverOutcomeCallable ModifyIpamPrefixListResolverCallable(
      const ModifyIpamPrefixListResolverRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamPrefixListResolver, request);
  }

  /**
   * An Async wrapper for ModifyIpamPrefixListResolver that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ModifyIpamPrefixListResolverRequestT = Model::ModifyIpamPrefixListResolverRequest>
  void ModifyIpamPrefixListResolverAsync(const ModifyIpamPrefixListResolverRequestT& request,
                                         const ModifyIpamPrefixListResolverResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIpamPrefixListResolver, request, handler, context);
  }

  /**
   * <p>Modifies an IPAM prefix list resolver target. You can update version tracking
   * settings and the desired version of the target prefix list.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamPrefixListResolverTarget">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyIpamPrefixListResolverTargetOutcome ModifyIpamPrefixListResolverTarget(
      const Model::ModifyIpamPrefixListResolverTargetRequest& request) const;

  /**
   * A Callable wrapper for ModifyIpamPrefixListResolverTarget that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename ModifyIpamPrefixListResolverTargetRequestT = Model::ModifyIpamPrefixListResolverTargetRequest>
  Model::ModifyIpamPrefixListResolverTargetOutcomeCallable ModifyIpamPrefixListResolverTargetCallable(
      const ModifyIpamPrefixListResolverTargetRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamPrefixListResolverTarget, request);
  }

  /**
   * An Async wrapper for ModifyIpamPrefixListResolverTarget that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename ModifyIpamPrefixListResolverTargetRequestT = Model::ModifyIpamPrefixListResolverTargetRequest>
  void ModifyIpamPrefixListResolverTargetAsync(const ModifyIpamPrefixListResolverTargetRequestT& request,
                                               const ModifyIpamPrefixListResolverTargetResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIpamPrefixListResolverTarget, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/move-resource-ipam.html">Move
   * resource CIDRs between scopes</a> and <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/change-monitoring-state-ipam.html">Change
   * the monitoring state of resource CIDRs</a> in the <i>Amazon VPC IPAM User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamResourceCidr">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyIpamResourceCidrRequestT = Model::ModifyIpamResourceCidrRequest>
  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 <typename ModifyIpamResourceCidrRequestT = Model::ModifyIpamResourceCidrRequest>
  void ModifyIpamResourceCidrAsync(const ModifyIpamResourceCidrRequestT& request,
                                   const ModifyIpamResourceCidrResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIpamResourceCidr, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamResourceDiscovery">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyIpamResourceDiscoveryRequestT = Model::ModifyIpamResourceDiscoveryRequest>
  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 <typename ModifyIpamResourceDiscoveryRequestT = Model::ModifyIpamResourceDiscoveryRequest>
  void ModifyIpamResourceDiscoveryAsync(const ModifyIpamResourceDiscoveryRequestT& request,
                                        const ModifyIpamResourceDiscoveryResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIpamResourceDiscovery, request, handler, context);
  }

  /**
   * <p>Modify an IPAM scope.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamScope">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyIpamScopeRequestT = Model::ModifyIpamScopeRequest>
  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 <typename ModifyIpamScopeRequestT = Model::ModifyIpamScopeRequest>
  void ModifyIpamScopeAsync(const ModifyIpamScopeRequestT& request, const ModifyIpamScopeResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIpamScope, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyLaunchTemplate">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyLaunchTemplateRequestT = Model::ModifyLaunchTemplateRequest>
  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 <typename ModifyLaunchTemplateRequestT = Model::ModifyLaunchTemplateRequest>
  void ModifyLaunchTemplateAsync(const ModifyLaunchTemplateResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ModifyLaunchTemplateRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ModifyLaunchTemplate, request, handler, context);
  }

  /**
   * <p>Modifies the specified local gateway route.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyLocalGatewayRoute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyLocalGatewayRouteRequestT = Model::ModifyLocalGatewayRouteRequest>
  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 <typename ModifyLocalGatewayRouteRequestT = Model::ModifyLocalGatewayRouteRequest>
  void ModifyLocalGatewayRouteAsync(const ModifyLocalGatewayRouteRequestT& request,
                                    const ModifyLocalGatewayRouteResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyLocalGatewayRoute, request, handler, context);
  }

  /**
   * <p>Modifies the specified managed prefix list.</p> <p>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.</p> <p>If you specify a current
   * version number that does not match the true current version number, the request
   * fails.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyManagedPrefixList">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyManagedPrefixListRequestT = Model::ModifyManagedPrefixListRequest>
  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 <typename ModifyManagedPrefixListRequestT = Model::ModifyManagedPrefixListRequest>
  void ModifyManagedPrefixListAsync(const ModifyManagedPrefixListRequestT& request,
                                    const ModifyManagedPrefixListResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyManagedPrefixList, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyNetworkInterfaceAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyNetworkInterfaceAttributeRequestT = Model::ModifyNetworkInterfaceAttributeRequest>
  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 <typename ModifyNetworkInterfaceAttributeRequestT = Model::ModifyNetworkInterfaceAttributeRequest>
  void ModifyNetworkInterfaceAttributeAsync(const ModifyNetworkInterfaceAttributeRequestT& request,
                                            const ModifyNetworkInterfaceAttributeResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyNetworkInterfaceAttribute, request, handler, context);
  }

  /**
   * <p>Modifies the options for instance hostnames for the specified
   * instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyPrivateDnsNameOptions">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyPrivateDnsNameOptionsRequestT = Model::ModifyPrivateDnsNameOptionsRequest>
  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 <typename ModifyPrivateDnsNameOptionsRequestT = Model::ModifyPrivateDnsNameOptionsRequest>
  void ModifyPrivateDnsNameOptionsAsync(const ModifyPrivateDnsNameOptionsRequestT& request,
                                        const ModifyPrivateDnsNameOptionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyPrivateDnsNameOptions, request, handler, context);
  }

  /**
   * <p>Modify public hostname options for a network interface. For more information,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-naming.html">EC2
   * instance hostnames, DNS names, and domains</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyPublicIpDnsNameOptions">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyPublicIpDnsNameOptionsOutcome ModifyPublicIpDnsNameOptions(
      const Model::ModifyPublicIpDnsNameOptionsRequest& request) const;

  /**
   * A Callable wrapper for ModifyPublicIpDnsNameOptions that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ModifyPublicIpDnsNameOptionsRequestT = Model::ModifyPublicIpDnsNameOptionsRequest>
  Model::ModifyPublicIpDnsNameOptionsOutcomeCallable ModifyPublicIpDnsNameOptionsCallable(
      const ModifyPublicIpDnsNameOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyPublicIpDnsNameOptions, request);
  }

  /**
   * An Async wrapper for ModifyPublicIpDnsNameOptions that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ModifyPublicIpDnsNameOptionsRequestT = Model::ModifyPublicIpDnsNameOptionsRequest>
  void ModifyPublicIpDnsNameOptionsAsync(const ModifyPublicIpDnsNameOptionsRequestT& request,
                                         const ModifyPublicIpDnsNameOptionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyPublicIpDnsNameOptions, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-modifying.html">Modify
   * Reserved Instances</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyReservedInstances">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyReservedInstancesRequestT = Model::ModifyReservedInstancesRequest>
  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 <typename ModifyReservedInstancesRequestT = Model::ModifyReservedInstancesRequest>
  void ModifyReservedInstancesAsync(const ModifyReservedInstancesRequestT& request,
                                    const ModifyReservedInstancesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyReservedInstances, request, handler, context);
  }

  /**
   * <p>Modifies the configuration of an existing route server.</p> <p>Amazon VPC
   * Route Server simplifies routing for traffic between workloads that are deployed
   * within a VPC and its internet gateways. With this feature, VPC Route Server
   * dynamically updates VPC and internet gateway route tables with your preferred
   * IPv4 or IPv6 routes to achieve routing fault tolerance for those workloads. This
   * enables you to automatically reroute traffic within a VPC, which increases the
   * manageability of VPC routing and interoperability with third-party
   * workloads.</p> <p>Route server supports the follow route table types:</p> <ul>
   * <li> <p>VPC route tables not associated with subnets</p> </li> <li> <p>Subnet
   * route tables</p> </li> <li> <p>Internet gateway route tables</p> </li> </ul>
   * <p>Route server does not support route tables associated with virtual private
   * gateways. To propagate routes into a transit gateway route table, use <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html">Transit
   * Gateway Connect</a>.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/dynamic-routing-route-server.html">Dynamic
   * routing in your VPC with VPC Route Server</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyRouteServer">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyRouteServerOutcome ModifyRouteServer(const Model::ModifyRouteServerRequest& request) const;

  /**
   * A Callable wrapper for ModifyRouteServer that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ModifyRouteServerRequestT = Model::ModifyRouteServerRequest>
  Model::ModifyRouteServerOutcomeCallable ModifyRouteServerCallable(const ModifyRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyRouteServer, request);
  }

  /**
   * An Async wrapper for ModifyRouteServer that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename ModifyRouteServerRequestT = Model::ModifyRouteServerRequest>
  void ModifyRouteServerAsync(const ModifyRouteServerRequestT& request, const ModifyRouteServerResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyRouteServer, request, handler, context);
  }

  /**
   * <p>Modifies the rules of a security group.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySecurityGroupRules">AWS
   * API Reference</a></p>
   */
  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 <typename ModifySecurityGroupRulesRequestT = Model::ModifySecurityGroupRulesRequest>
  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 <typename ModifySecurityGroupRulesRequestT = Model::ModifySecurityGroupRulesRequest>
  void ModifySecurityGroupRulesAsync(const ModifySecurityGroupRulesRequestT& request,
                                     const ModifySecurityGroupRulesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifySecurityGroupRules, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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.</p> <p>For more
   * information about modifying snapshot permissions, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modifying-snapshot-permissions.html">Share
   * a snapshot</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySnapshotAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifySnapshotAttributeRequestT = Model::ModifySnapshotAttributeRequest>
  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 <typename ModifySnapshotAttributeRequestT = Model::ModifySnapshotAttributeRequest>
  void ModifySnapshotAttributeAsync(const ModifySnapshotAttributeRequestT& request,
                                    const ModifySnapshotAttributeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifySnapshotAttribute, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html">Archive
   * Amazon EBS snapshots</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySnapshotTier">AWS
   * API Reference</a></p>
   */
  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 <typename ModifySnapshotTierRequestT = Model::ModifySnapshotTierRequest>
  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 <typename ModifySnapshotTierRequestT = Model::ModifySnapshotTierRequest>
  void ModifySnapshotTierAsync(const ModifySnapshotTierRequestT& request, const ModifySnapshotTierResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifySnapshotTier, request, handler, context);
  }

  /**
   * <p>Modifies the specified Spot Fleet request.</p> <p>You can only modify a Spot
   * Fleet request of type <code>maintain</code>.</p> <p>While the Spot Fleet request
   * is being modified, it is in the <code>modifying</code> state.</p> <p>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 <code>lowestPrice</code>, the Spot
   * Fleet launches instances using the Spot Instance pool with the lowest price. If
   * the allocation strategy is <code>diversified</code>, the Spot Fleet distributes
   * the instances across the Spot Instance pools. If the allocation strategy is
   * <code>capacityOptimized</code>, Spot Fleet launches instances from Spot Instance
   * pools with optimal capacity for the number of instances that are launching.</p>
   * <p>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
   * <code>lowestPrice</code>, the Spot Fleet terminates the instances with the
   * highest price per unit. If the allocation strategy is
   * <code>capacityOptimized</code>, the Spot Fleet terminates the instances in the
   * Spot Instance pools that have the least available Spot Instance capacity. If the
   * allocation strategy is <code>diversified</code>, 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.</p> <p>If you are
   * finished with your Spot Fleet for now, but will use it again later, you can set
   * the target capacity to 0.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySpotFleetRequest">AWS
   * API Reference</a></p>
   */
  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 <typename ModifySpotFleetRequestRequestT = Model::ModifySpotFleetRequestRequest>
  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 <typename ModifySpotFleetRequestRequestT = Model::ModifySpotFleetRequestRequest>
  void ModifySpotFleetRequestAsync(const ModifySpotFleetRequestRequestT& request,
                                   const ModifySpotFleetRequestResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifySpotFleetRequest, request, handler, context);
  }

  /**
   * <p>Modifies a subnet attribute. You can only modify one attribute at a time.</p>
   * <p>Use this action to modify subnets on Amazon Web Services Outposts.</p> <ul>
   * <li> <p>To modify a subnet on an Outpost rack, set both
   * <code>MapCustomerOwnedIpOnLaunch</code> and <code>CustomerOwnedIpv4Pool</code>.
   * These two parameters act as a single attribute.</p> </li> <li> <p>To modify a
   * subnet on an Outpost server, set either <code>EnableLniAtDeviceIndex</code> or
   * <code>DisableLniAtDeviceIndex</code>.</p> </li> </ul> <p>For more information
   * about Amazon Web Services Outposts, see the following:</p> <ul> <li> <p> <a
   * href="https://docs.aws.amazon.com/outposts/latest/userguide/how-servers-work.html">Outpost
   * servers</a> </p> </li> <li> <p> <a
   * href="https://docs.aws.amazon.com/outposts/latest/userguide/how-racks-work.html">Outpost
   * racks</a> </p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySubnetAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifySubnetAttributeRequestT = Model::ModifySubnetAttributeRequest>
  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 <typename ModifySubnetAttributeRequestT = Model::ModifySubnetAttributeRequest>
  void ModifySubnetAttributeAsync(const ModifySubnetAttributeRequestT& request, const ModifySubnetAttributeResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifySubnetAttribute, request, handler, context);
  }

  /**
   * <p>Allows or restricts mirroring network services.</p> <p> By default, Amazon
   * DNS network services are not eligible for Traffic Mirror. Use
   * <code>AddNetworkServices</code> 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 <code>RemoveNetworkServices</code> to
   * remove the network services from the Traffic Mirror filter. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorFilterNetworkServices">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyTrafficMirrorFilterNetworkServicesRequestT = Model::ModifyTrafficMirrorFilterNetworkServicesRequest>
  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 <typename ModifyTrafficMirrorFilterNetworkServicesRequestT = Model::ModifyTrafficMirrorFilterNetworkServicesRequest>
  void ModifyTrafficMirrorFilterNetworkServicesAsync(
      const ModifyTrafficMirrorFilterNetworkServicesRequestT& request,
      const ModifyTrafficMirrorFilterNetworkServicesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyTrafficMirrorFilterNetworkServices, request, handler, context);
  }

  /**
   * <p>Modifies the specified Traffic Mirror rule.</p> <p>
   * <code>DestinationCidrBlock</code> and <code>SourceCidrBlock</code> must both be
   * an IPv4 range or an IPv6 range.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorFilterRule">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyTrafficMirrorFilterRuleRequestT = Model::ModifyTrafficMirrorFilterRuleRequest>
  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 <typename ModifyTrafficMirrorFilterRuleRequestT = Model::ModifyTrafficMirrorFilterRuleRequest>
  void ModifyTrafficMirrorFilterRuleAsync(const ModifyTrafficMirrorFilterRuleRequestT& request,
                                          const ModifyTrafficMirrorFilterRuleResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyTrafficMirrorFilterRule, request, handler, context);
  }

  /**
   * <p>Modifies a Traffic Mirror session.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorSession">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyTrafficMirrorSessionRequestT = Model::ModifyTrafficMirrorSessionRequest>
  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 <typename ModifyTrafficMirrorSessionRequestT = Model::ModifyTrafficMirrorSessionRequest>
  void ModifyTrafficMirrorSessionAsync(const ModifyTrafficMirrorSessionRequestT& request,
                                       const ModifyTrafficMirrorSessionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyTrafficMirrorSession, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGateway">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyTransitGatewayRequestT = Model::ModifyTransitGatewayRequest>
  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 <typename ModifyTransitGatewayRequestT = Model::ModifyTransitGatewayRequest>
  void ModifyTransitGatewayAsync(const ModifyTransitGatewayRequestT& request, const ModifyTransitGatewayResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyTransitGateway, request, handler, context);
  }

  /**
   * <p>Modifies a transit gateway metering policy.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGatewayMeteringPolicy">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyTransitGatewayMeteringPolicyOutcome ModifyTransitGatewayMeteringPolicy(
      const Model::ModifyTransitGatewayMeteringPolicyRequest& request) const;

  /**
   * A Callable wrapper for ModifyTransitGatewayMeteringPolicy that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename ModifyTransitGatewayMeteringPolicyRequestT = Model::ModifyTransitGatewayMeteringPolicyRequest>
  Model::ModifyTransitGatewayMeteringPolicyOutcomeCallable ModifyTransitGatewayMeteringPolicyCallable(
      const ModifyTransitGatewayMeteringPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyTransitGatewayMeteringPolicy, request);
  }

  /**
   * An Async wrapper for ModifyTransitGatewayMeteringPolicy that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename ModifyTransitGatewayMeteringPolicyRequestT = Model::ModifyTransitGatewayMeteringPolicyRequest>
  void ModifyTransitGatewayMeteringPolicyAsync(const ModifyTransitGatewayMeteringPolicyRequestT& request,
                                               const ModifyTransitGatewayMeteringPolicyResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyTransitGatewayMeteringPolicy, request, handler, context);
  }

  /**
   * <p>Modifies a reference (route) to a prefix list in a specified transit gateway
   * route table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGatewayPrefixListReference">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyTransitGatewayPrefixListReferenceRequestT = Model::ModifyTransitGatewayPrefixListReferenceRequest>
  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 <typename ModifyTransitGatewayPrefixListReferenceRequestT = Model::ModifyTransitGatewayPrefixListReferenceRequest>
  void ModifyTransitGatewayPrefixListReferenceAsync(const ModifyTransitGatewayPrefixListReferenceRequestT& request,
                                                    const ModifyTransitGatewayPrefixListReferenceResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyTransitGatewayPrefixListReference, request, handler, context);
  }

  /**
   * <p>Modifies the specified VPC attachment.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGatewayVpcAttachment">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyTransitGatewayVpcAttachmentRequestT = Model::ModifyTransitGatewayVpcAttachmentRequest>
  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 <typename ModifyTransitGatewayVpcAttachmentRequestT = Model::ModifyTransitGatewayVpcAttachmentRequest>
  void ModifyTransitGatewayVpcAttachmentAsync(const ModifyTransitGatewayVpcAttachmentRequestT& request,
                                              const ModifyTransitGatewayVpcAttachmentResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyTransitGatewayVpcAttachment, request, handler, context);
  }

  /**
   * <p>Modifies the configuration of the specified Amazon Web Services Verified
   * Access endpoint.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVerifiedAccessEndpointRequestT = Model::ModifyVerifiedAccessEndpointRequest>
  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 <typename ModifyVerifiedAccessEndpointRequestT = Model::ModifyVerifiedAccessEndpointRequest>
  void ModifyVerifiedAccessEndpointAsync(const ModifyVerifiedAccessEndpointRequestT& request,
                                         const ModifyVerifiedAccessEndpointResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVerifiedAccessEndpoint, request, handler, context);
  }

  /**
   * <p>Modifies the specified Amazon Web Services Verified Access endpoint
   * policy.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessEndpointPolicy">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVerifiedAccessEndpointPolicyRequestT = Model::ModifyVerifiedAccessEndpointPolicyRequest>
  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 <typename ModifyVerifiedAccessEndpointPolicyRequestT = Model::ModifyVerifiedAccessEndpointPolicyRequest>
  void ModifyVerifiedAccessEndpointPolicyAsync(const ModifyVerifiedAccessEndpointPolicyRequestT& request,
                                               const ModifyVerifiedAccessEndpointPolicyResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVerifiedAccessEndpointPolicy, request, handler, context);
  }

  /**
   * <p>Modifies the specified Amazon Web Services Verified Access group
   * configuration.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessGroup">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVerifiedAccessGroupRequestT = Model::ModifyVerifiedAccessGroupRequest>
  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 <typename ModifyVerifiedAccessGroupRequestT = Model::ModifyVerifiedAccessGroupRequest>
  void ModifyVerifiedAccessGroupAsync(const ModifyVerifiedAccessGroupRequestT& request,
                                      const ModifyVerifiedAccessGroupResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVerifiedAccessGroup, request, handler, context);
  }

  /**
   * <p>Modifies the specified Amazon Web Services Verified Access group
   * policy.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessGroupPolicy">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVerifiedAccessGroupPolicyRequestT = Model::ModifyVerifiedAccessGroupPolicyRequest>
  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 <typename ModifyVerifiedAccessGroupPolicyRequestT = Model::ModifyVerifiedAccessGroupPolicyRequest>
  void ModifyVerifiedAccessGroupPolicyAsync(const ModifyVerifiedAccessGroupPolicyRequestT& request,
                                            const ModifyVerifiedAccessGroupPolicyResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVerifiedAccessGroupPolicy, request, handler, context);
  }

  /**
   * <p>Modifies the configuration of the specified Amazon Web Services Verified
   * Access instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessInstance">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVerifiedAccessInstanceRequestT = Model::ModifyVerifiedAccessInstanceRequest>
  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 <typename ModifyVerifiedAccessInstanceRequestT = Model::ModifyVerifiedAccessInstanceRequest>
  void ModifyVerifiedAccessInstanceAsync(const ModifyVerifiedAccessInstanceRequestT& request,
                                         const ModifyVerifiedAccessInstanceResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVerifiedAccessInstance, request, handler, context);
  }

  /**
   * <p>Modifies the logging configuration for the specified Amazon Web Services
   * Verified Access instance.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessInstanceLoggingConfiguration">AWS
   * API Reference</a></p>
   */
  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 <
      typename ModifyVerifiedAccessInstanceLoggingConfigurationRequestT = Model::ModifyVerifiedAccessInstanceLoggingConfigurationRequest>
  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 <
      typename ModifyVerifiedAccessInstanceLoggingConfigurationRequestT = Model::ModifyVerifiedAccessInstanceLoggingConfigurationRequest>
  void ModifyVerifiedAccessInstanceLoggingConfigurationAsync(
      const ModifyVerifiedAccessInstanceLoggingConfigurationRequestT& request,
      const ModifyVerifiedAccessInstanceLoggingConfigurationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVerifiedAccessInstanceLoggingConfiguration, request, handler, context);
  }

  /**
   * <p>Modifies the configuration of the specified Amazon Web Services Verified
   * Access trust provider.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessTrustProvider">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVerifiedAccessTrustProviderRequestT = Model::ModifyVerifiedAccessTrustProviderRequest>
  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 <typename ModifyVerifiedAccessTrustProviderRequestT = Model::ModifyVerifiedAccessTrustProviderRequest>
  void ModifyVerifiedAccessTrustProviderAsync(const ModifyVerifiedAccessTrustProviderRequestT& request,
                                              const ModifyVerifiedAccessTrustProviderResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVerifiedAccessTrustProvider, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html">Amazon
   * EBS Elastic Volumes</a> in the <i>Amazon EBS User Guide</i>.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/recognize-expanded-volume-linux.html">Extend
   * the file system</a>.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/monitoring-volume-modifications.html">Monitor
   * the progress of volume modifications</a> in the <i>Amazon EBS User
   * Guide</i>.</p> <p>With previous-generation instance types, resizing an EBS
   * volume might require detaching and reattaching the volume or stopping and
   * restarting the instance.</p> <p>After you initiate a volume modification, you
   * must wait for that modification to reach the <code>completed</code> state before
   * you can initiate another modification for the same volume. You can modify a
   * volume up to four times within a rolling 24-hour period, as long as the volume
   * is in the <code>in-use</code> or <code>available</code> state, and all previous
   * modifications for that volume are <code>completed</code>. If you exceed this
   * limit, you get an error message that indicates when you can perform your next
   * modification.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVolume">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVolumeRequestT = Model::ModifyVolumeRequest>
  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 <typename ModifyVolumeRequestT = Model::ModifyVolumeRequest>
  void ModifyVolumeAsync(const ModifyVolumeRequestT& request, const ModifyVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVolume, request, handler, context);
  }

  /**
   * <p>Modifies a volume attribute.</p> <p>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.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVolumeAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVolumeAttributeRequestT = Model::ModifyVolumeAttributeRequest>
  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 <typename ModifyVolumeAttributeRequestT = Model::ModifyVolumeAttributeRequest>
  void ModifyVolumeAttributeAsync(const ModifyVolumeAttributeRequestT& request, const ModifyVolumeAttributeResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVolumeAttribute, request, handler, context);
  }

  /**
   * <p>Modifies the specified attribute of the specified VPC.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpcAttributeRequestT = Model::ModifyVpcAttributeRequest>
  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 <typename ModifyVpcAttributeRequestT = Model::ModifyVpcAttributeRequest>
  void ModifyVpcAttributeAsync(const ModifyVpcAttributeRequestT& request, const ModifyVpcAttributeResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcAttribute, request, handler, context);
  }

  /**
   * <p>Modify VPC Block Public Access (BPA) exclusions. A VPC BPA exclusion is a
   * mode that can be applied to a single VPC or subnet that exempts it from the
   * account’s BPA mode and will allow bidirectional or egress-only access. You can
   * create BPA exclusions for VPCs and subnets even when BPA is not enabled on the
   * account to ensure that there is no traffic disruption to the exclusions when VPC
   * BPA is turned on.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcBlockPublicAccessExclusion">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyVpcBlockPublicAccessExclusionOutcome ModifyVpcBlockPublicAccessExclusion(
      const Model::ModifyVpcBlockPublicAccessExclusionRequest& request) const;

  /**
   * A Callable wrapper for ModifyVpcBlockPublicAccessExclusion that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename ModifyVpcBlockPublicAccessExclusionRequestT = Model::ModifyVpcBlockPublicAccessExclusionRequest>
  Model::ModifyVpcBlockPublicAccessExclusionOutcomeCallable ModifyVpcBlockPublicAccessExclusionCallable(
      const ModifyVpcBlockPublicAccessExclusionRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcBlockPublicAccessExclusion, request);
  }

  /**
   * An Async wrapper for ModifyVpcBlockPublicAccessExclusion that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename ModifyVpcBlockPublicAccessExclusionRequestT = Model::ModifyVpcBlockPublicAccessExclusionRequest>
  void ModifyVpcBlockPublicAccessExclusionAsync(const ModifyVpcBlockPublicAccessExclusionRequestT& request,
                                                const ModifyVpcBlockPublicAccessExclusionResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcBlockPublicAccessExclusion, request, handler, context);
  }

  /**
   * <p>Modify VPC Block Public Access (BPA) options. VPC Block Public Access (BPA)
   * enables you to block resources in VPCs and subnets that you own in a Region from
   * reaching or being reached from the internet through internet gateways and
   * egress-only internet gateways. To learn more about VPC BPA, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/security-vpc-bpa.html">Block
   * public access to VPCs and subnets</a> in the <i>Amazon VPC User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcBlockPublicAccessOptions">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyVpcBlockPublicAccessOptionsOutcome ModifyVpcBlockPublicAccessOptions(
      const Model::ModifyVpcBlockPublicAccessOptionsRequest& request) const;

  /**
   * A Callable wrapper for ModifyVpcBlockPublicAccessOptions that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename ModifyVpcBlockPublicAccessOptionsRequestT = Model::ModifyVpcBlockPublicAccessOptionsRequest>
  Model::ModifyVpcBlockPublicAccessOptionsOutcomeCallable ModifyVpcBlockPublicAccessOptionsCallable(
      const ModifyVpcBlockPublicAccessOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcBlockPublicAccessOptions, request);
  }

  /**
   * An Async wrapper for ModifyVpcBlockPublicAccessOptions that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename ModifyVpcBlockPublicAccessOptionsRequestT = Model::ModifyVpcBlockPublicAccessOptionsRequest>
  void ModifyVpcBlockPublicAccessOptionsAsync(const ModifyVpcBlockPublicAccessOptionsRequestT& request,
                                              const ModifyVpcBlockPublicAccessOptionsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcBlockPublicAccessOptions, request, handler, context);
  }

  /**
   * <p>Modifies the encryption control configuration for a VPC. You can update the
   * encryption mode and exclusion settings for various gateway types and peering
   * connections.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-encryption-controls.html">Enforce
   * VPC encryption in transit</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEncryptionControl">AWS
   * API Reference</a></p>
   */
  virtual Model::ModifyVpcEncryptionControlOutcome ModifyVpcEncryptionControl(
      const Model::ModifyVpcEncryptionControlRequest& request) const;

  /**
   * A Callable wrapper for ModifyVpcEncryptionControl that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename ModifyVpcEncryptionControlRequestT = Model::ModifyVpcEncryptionControlRequest>
  Model::ModifyVpcEncryptionControlOutcomeCallable ModifyVpcEncryptionControlCallable(
      const ModifyVpcEncryptionControlRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcEncryptionControl, request);
  }

  /**
   * An Async wrapper for ModifyVpcEncryptionControl that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename ModifyVpcEncryptionControlRequestT = Model::ModifyVpcEncryptionControlRequest>
  void ModifyVpcEncryptionControlAsync(const ModifyVpcEncryptionControlRequestT& request,
                                       const ModifyVpcEncryptionControlResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcEncryptionControl, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/privatelink/">Amazon Web Services
   * PrivateLink Guide</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpoint">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpcEndpointRequestT = Model::ModifyVpcEndpointRequest>
  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 <typename ModifyVpcEndpointRequestT = Model::ModifyVpcEndpointRequest>
  void ModifyVpcEndpointAsync(const ModifyVpcEndpointRequestT& request, const ModifyVpcEndpointResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcEndpoint, request, handler, context);
  }

  /**
   * <p>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. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointConnectionNotification">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpcEndpointConnectionNotificationRequestT = Model::ModifyVpcEndpointConnectionNotificationRequest>
  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 <typename ModifyVpcEndpointConnectionNotificationRequestT = Model::ModifyVpcEndpointConnectionNotificationRequest>
  void ModifyVpcEndpointConnectionNotificationAsync(const ModifyVpcEndpointConnectionNotificationRequestT& request,
                                                    const ModifyVpcEndpointConnectionNotificationResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcEndpointConnectionNotification, request, handler, context);
  }

  /**
   * <p>Modifies the attributes of the specified VPC endpoint service
   * configuration.</p> <p>If you set or modify the private DNS name, you must prove
   * that you own the private DNS domain name.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServiceConfiguration">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpcEndpointServiceConfigurationRequestT = Model::ModifyVpcEndpointServiceConfigurationRequest>
  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 <typename ModifyVpcEndpointServiceConfigurationRequestT = Model::ModifyVpcEndpointServiceConfigurationRequest>
  void ModifyVpcEndpointServiceConfigurationAsync(const ModifyVpcEndpointServiceConfigurationRequestT& request,
                                                  const ModifyVpcEndpointServiceConfigurationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcEndpointServiceConfiguration, request, handler, context);
  }

  /**
   * <p>Modifies the payer responsibility for your VPC endpoint
   * service.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServicePayerResponsibility">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpcEndpointServicePayerResponsibilityRequestT = Model::ModifyVpcEndpointServicePayerResponsibilityRequest>
  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 <typename ModifyVpcEndpointServicePayerResponsibilityRequestT = Model::ModifyVpcEndpointServicePayerResponsibilityRequest>
  void ModifyVpcEndpointServicePayerResponsibilityAsync(
      const ModifyVpcEndpointServicePayerResponsibilityRequestT& request,
      const ModifyVpcEndpointServicePayerResponsibilityResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcEndpointServicePayerResponsibility, request, handler, context);
  }

  /**
   * <p>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. Principal ARNs with path components
   * aren't supported.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServicePermissions">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpcEndpointServicePermissionsRequestT = Model::ModifyVpcEndpointServicePermissionsRequest>
  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 <typename ModifyVpcEndpointServicePermissionsRequestT = Model::ModifyVpcEndpointServicePermissionsRequest>
  void ModifyVpcEndpointServicePermissionsAsync(const ModifyVpcEndpointServicePermissionsRequestT& request,
                                                const ModifyVpcEndpointServicePermissionsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcEndpointServicePermissions, request, handler, context);
  }

  /**
   * <p>Modifies the VPC peering connection options on one side of a VPC peering
   * connection.</p> <p>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
   * <a>DescribeVpcPeeringConnections</a> command.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcPeeringConnectionOptions">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpcPeeringConnectionOptionsRequestT = Model::ModifyVpcPeeringConnectionOptionsRequest>
  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 <typename ModifyVpcPeeringConnectionOptionsRequestT = Model::ModifyVpcPeeringConnectionOptionsRequest>
  void ModifyVpcPeeringConnectionOptionsAsync(const ModifyVpcPeeringConnectionOptionsRequestT& request,
                                              const ModifyVpcPeeringConnectionOptionsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcPeeringConnectionOptions, request, handler, context);
  }

  /**
   * <p>Modifies the instance tenancy attribute of the specified VPC. You can change
   * the instance tenancy attribute of a VPC to <code>default</code> only. You cannot
   * change the instance tenancy attribute to <code>dedicated</code>.</p> <p>After
   * you modify the tenancy of the VPC, any new instances that you launch into the
   * VPC have a tenancy of <code>default</code>, unless you specify otherwise during
   * launch. The tenancy of any existing instances in the VPC is not affected.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html">Dedicated
   * Instances</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcTenancy">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpcTenancyRequestT = Model::ModifyVpcTenancyRequest>
  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 <typename ModifyVpcTenancyRequestT = Model::ModifyVpcTenancyRequest>
  void ModifyVpcTenancyAsync(const ModifyVpcTenancyRequestT& request, const ModifyVpcTenancyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcTenancy, request, handler, context);
  }

  /**
   * <p>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:</p> <ul> <li> <p>An existing virtual private
   * gateway to a new virtual private gateway</p> </li> <li> <p>An existing virtual
   * private gateway to a transit gateway</p> </li> <li> <p>An existing transit
   * gateway to a new transit gateway</p> </li> <li> <p>An existing transit gateway
   * to a virtual private gateway</p> </li> </ul> <p>Before you perform the migration
   * to the new gateway, you must configure the new gateway. Use
   * <a>CreateVpnGateway</a> to create a virtual private gateway, or
   * <a>CreateTransitGateway</a> to create a transit gateway.</p> <p>This step is
   * required when you migrate from a virtual private gateway with static routes to a
   * transit gateway. </p> <p>You must delete the static routes before you migrate to
   * the new gateway.</p> <p>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.</p> <p>After you migrate to the new gateway,
   * you might need to modify your VPC route table. Use <a>CreateRoute</a> and
   * <a>DeleteRoute</a> to make the changes described in <a
   * href="https://docs.aws.amazon.com/vpn/latest/s2svpn/modify-vpn-target.html#step-update-routing">Update
   * VPC route tables</a> in the <i>Amazon Web Services Site-to-Site VPN User
   * Guide</i>.</p> <p>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 <a>CreateTransitGatewayRoute</a> to add the
   * routes.</p> <p> If you deleted VPN static routes, you must add the static routes
   * to the transit gateway route table.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnConnection">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpnConnectionRequestT = Model::ModifyVpnConnectionRequest>
  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 <typename ModifyVpnConnectionRequestT = Model::ModifyVpnConnectionRequest>
  void ModifyVpnConnectionAsync(const ModifyVpnConnectionRequestT& request, const ModifyVpnConnectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpnConnection, request, handler, context);
  }

  /**
   * <p>Modifies the connection options for your Site-to-Site VPN connection.</p>
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnConnectionOptions">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpnConnectionOptionsRequestT = Model::ModifyVpnConnectionOptionsRequest>
  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 <typename ModifyVpnConnectionOptionsRequestT = Model::ModifyVpnConnectionOptionsRequest>
  void ModifyVpnConnectionOptionsAsync(const ModifyVpnConnectionOptionsRequestT& request,
                                       const ModifyVpnConnectionOptionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpnConnectionOptions, request, handler, context);
  }

  /**
   * <p>Modifies the VPN tunnel endpoint certificate.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnTunnelCertificate">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpnTunnelCertificateRequestT = Model::ModifyVpnTunnelCertificateRequest>
  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 <typename ModifyVpnTunnelCertificateRequestT = Model::ModifyVpnTunnelCertificateRequest>
  void ModifyVpnTunnelCertificateAsync(const ModifyVpnTunnelCertificateRequestT& request,
                                       const ModifyVpnTunnelCertificateResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpnTunnelCertificate, request, handler, context);
  }

  /**
   * <p>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
   * <a
   * href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPNTunnels.html">Site-to-Site
   * VPN tunnel options for your Site-to-Site VPN connection</a> in the <i>Amazon Web
   * Services Site-to-Site VPN User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnTunnelOptions">AWS
   * API Reference</a></p>
   */
  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 <typename ModifyVpnTunnelOptionsRequestT = Model::ModifyVpnTunnelOptionsRequest>
  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 <typename ModifyVpnTunnelOptionsRequestT = Model::ModifyVpnTunnelOptionsRequest>
  void ModifyVpnTunnelOptionsAsync(const ModifyVpnTunnelOptionsRequestT& request,
                                   const ModifyVpnTunnelOptionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpnTunnelOptions, request, handler, context);
  }

  /**
   * <p>Enables detailed monitoring for a running instance. Otherwise, basic
   * monitoring is enabled. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch.html">Monitor
   * your instances using CloudWatch</a> in the <i>Amazon EC2 User Guide</i>.</p>
   * <p>To disable detailed monitoring, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html">UnmonitorInstances</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MonitorInstances">AWS
   * API Reference</a></p>
   */
  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 <typename MonitorInstancesRequestT = Model::MonitorInstancesRequest>
  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 <typename MonitorInstancesRequestT = Model::MonitorInstancesRequest>
  void MonitorInstancesAsync(const MonitorInstancesRequestT& request, const MonitorInstancesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::MonitorInstances, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>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. You cannot move an Elastic
   * IP address that was originally allocated for use in the EC2-VPC platform to the
   * EC2-Classic platform.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MoveAddressToVpc">AWS
   * API Reference</a></p>
   */
  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 <typename MoveAddressToVpcRequestT = Model::MoveAddressToVpcRequest>
  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 <typename MoveAddressToVpcRequestT = Model::MoveAddressToVpcRequest>
  void MoveAddressToVpcAsync(const MoveAddressToVpcRequestT& request, const MoveAddressToVpcResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::MoveAddressToVpc, request, handler, context);
  }

  /**
   * <p>Move a BYOIPv4 CIDR to IPAM from a public IPv4 pool.</p> <p>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
   * <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoip-ipam.html">Tutorial:
   * BYOIP address CIDRs to IPAM</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MoveByoipCidrToIpam">AWS
   * API Reference</a></p>
   */
  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 <typename MoveByoipCidrToIpamRequestT = Model::MoveByoipCidrToIpamRequest>
  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 <typename MoveByoipCidrToIpamRequestT = Model::MoveByoipCidrToIpamRequest>
  void MoveByoipCidrToIpamAsync(const MoveByoipCidrToIpamRequestT& request, const MoveByoipCidrToIpamResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::MoveByoipCidrToIpam, request, handler, context);
  }

  /**
   * <p>Move available capacity from a source Capacity Reservation to a destination
   * Capacity Reservation. The source Capacity Reservation and the destination
   * Capacity Reservation must be <code>active</code>, owned by your Amazon Web
   * Services account, and share the following: </p> <ul> <li> <p>Instance type</p>
   * </li> <li> <p>Platform</p> </li> <li> <p>Availability Zone</p> </li> <li>
   * <p>Tenancy</p> </li> <li> <p>Placement group</p> </li> <li> <p>Capacity
   * Reservation end time - <code>At specific time</code> or
   * <code>Manually</code>.</p> </li> </ul><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MoveCapacityReservationInstances">AWS
   * API Reference</a></p>
   */
  virtual Model::MoveCapacityReservationInstancesOutcome MoveCapacityReservationInstances(
      const Model::MoveCapacityReservationInstancesRequest& request) const;

  /**
   * A Callable wrapper for MoveCapacityReservationInstances that returns a future to the operation so that it can be executed in parallel
   * to other requests.
   */
  template <typename MoveCapacityReservationInstancesRequestT = Model::MoveCapacityReservationInstancesRequest>
  Model::MoveCapacityReservationInstancesOutcomeCallable MoveCapacityReservationInstancesCallable(
      const MoveCapacityReservationInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::MoveCapacityReservationInstances, request);
  }

  /**
   * An Async wrapper for MoveCapacityReservationInstances that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename MoveCapacityReservationInstancesRequestT = Model::MoveCapacityReservationInstancesRequest>
  void MoveCapacityReservationInstancesAsync(const MoveCapacityReservationInstancesRequestT& request,
                                             const MoveCapacityReservationInstancesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::MoveCapacityReservationInstances, request, handler, context);
  }

  /**
   * <p>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.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">Bring
   * your own IP addresses (BYOIP)</a> in the <i>Amazon EC2 User Guide</i>.</p>
   * <p>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 <code>pending-provision</code> to <code>provisioned</code>. For
   * more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/byoip-onboard.html">Onboard
   * your address range</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionByoipCidr">AWS
   * API Reference</a></p>
   */
  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 <typename ProvisionByoipCidrRequestT = Model::ProvisionByoipCidrRequest>
  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 <typename ProvisionByoipCidrRequestT = Model::ProvisionByoipCidrRequest>
  void ProvisionByoipCidrAsync(const ProvisionByoipCidrRequestT& request, const ProvisionByoipCidrResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ProvisionByoipCidr, request, handler, context);
  }

  /**
   * <p>Provisions your Autonomous System Number (ASN) for use in your Amazon Web
   * Services account. This action requires authorization context for Amazon to bring
   * the ASN to an Amazon Web Services account. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoasn.html">Tutorial:
   * Bring your ASN to IPAM</a> in the <i>Amazon VPC IPAM guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionIpamByoasn">AWS
   * API Reference</a></p>
   */
  virtual Model::ProvisionIpamByoasnOutcome ProvisionIpamByoasn(const Model::ProvisionIpamByoasnRequest& request) const;

  /**
   * A Callable wrapper for ProvisionIpamByoasn that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename ProvisionIpamByoasnRequestT = Model::ProvisionIpamByoasnRequest>
  Model::ProvisionIpamByoasnOutcomeCallable ProvisionIpamByoasnCallable(const ProvisionIpamByoasnRequestT& request) const {
    return SubmitCallable(&EC2Client::ProvisionIpamByoasn, request);
  }

  /**
   * An Async wrapper for ProvisionIpamByoasn that queues the request into a thread executor and triggers associated callback when operation
   * has finished.
   */
  template <typename ProvisionIpamByoasnRequestT = Model::ProvisionIpamByoasnRequest>
  void ProvisionIpamByoasnAsync(const ProvisionIpamByoasnRequestT& request, const ProvisionIpamByoasnResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ProvisionIpamByoasn, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/prov-cidr-ipam.html">Provision
   * CIDRs to pools</a> in the <i>Amazon VPC IPAM User Guide</i>. </p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionIpamPoolCidr">AWS
   * API Reference</a></p>
   */
  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 <typename ProvisionIpamPoolCidrRequestT = Model::ProvisionIpamPoolCidrRequest>
  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 <typename ProvisionIpamPoolCidrRequestT = Model::ProvisionIpamPoolCidrRequest>
  void ProvisionIpamPoolCidrAsync(const ProvisionIpamPoolCidrRequestT& request, const ProvisionIpamPoolCidrResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ProvisionIpamPoolCidr, request, handler, context);
  }

  /**
   * <p>Provision a CIDR to a public IPv4 pool.</p> <p>For more information about
   * IPAM, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/what-is-it-ipam.html">What is
   * IPAM?</a> in the <i>Amazon VPC IPAM User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionPublicIpv4PoolCidr">AWS
   * API Reference</a></p>
   */
  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 <typename ProvisionPublicIpv4PoolCidrRequestT = Model::ProvisionPublicIpv4PoolCidrRequest>
  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 <typename ProvisionPublicIpv4PoolCidrRequestT = Model::ProvisionPublicIpv4PoolCidrRequest>
  void ProvisionPublicIpv4PoolCidrAsync(const ProvisionPublicIpv4PoolCidrRequestT& request,
                                        const ProvisionPublicIpv4PoolCidrResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ProvisionPublicIpv4PoolCidr, request, handler, context);
  }

  /**
   * <p>Purchase the Capacity Block for use with your account. With Capacity Blocks
   * you ensure GPU capacity is available for machine learning (ML) workloads. You
   * must specify the ID of the Capacity Block offering you are
   * purchasing.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseCapacityBlock">AWS
   * API Reference</a></p>
   */
  virtual Model::PurchaseCapacityBlockOutcome PurchaseCapacityBlock(const Model::PurchaseCapacityBlockRequest& request) const;

  /**
   * A Callable wrapper for PurchaseCapacityBlock that returns a future to the operation so that it can be executed in parallel to other
   * requests.
   */
  template <typename PurchaseCapacityBlockRequestT = Model::PurchaseCapacityBlockRequest>
  Model::PurchaseCapacityBlockOutcomeCallable PurchaseCapacityBlockCallable(const PurchaseCapacityBlockRequestT& request) const {
    return SubmitCallable(&EC2Client::PurchaseCapacityBlock, request);
  }

  /**
   * An Async wrapper for PurchaseCapacityBlock that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename PurchaseCapacityBlockRequestT = Model::PurchaseCapacityBlockRequest>
  void PurchaseCapacityBlockAsync(const PurchaseCapacityBlockRequestT& request, const PurchaseCapacityBlockResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::PurchaseCapacityBlock, request, handler, context);
  }

  /**
   * <p>Purchase the Capacity Block extension for use with your account. You must
   * specify the ID of the Capacity Block extension offering you are
   * purchasing.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseCapacityBlockExtension">AWS
   * API Reference</a></p>
   */
  virtual Model::PurchaseCapacityBlockExtensionOutcome PurchaseCapacityBlockExtension(
      const Model::PurchaseCapacityBlockExtensionRequest& request) const;

  /**
   * A Callable wrapper for PurchaseCapacityBlockExtension that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename PurchaseCapacityBlockExtensionRequestT = Model::PurchaseCapacityBlockExtensionRequest>
  Model::PurchaseCapacityBlockExtensionOutcomeCallable PurchaseCapacityBlockExtensionCallable(
      const PurchaseCapacityBlockExtensionRequestT& request) const {
    return SubmitCallable(&EC2Client::PurchaseCapacityBlockExtension, request);
  }

  /**
   * An Async wrapper for PurchaseCapacityBlockExtension that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename PurchaseCapacityBlockExtensionRequestT = Model::PurchaseCapacityBlockExtensionRequest>
  void PurchaseCapacityBlockExtensionAsync(const PurchaseCapacityBlockExtensionRequestT& request,
                                           const PurchaseCapacityBlockExtensionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::PurchaseCapacityBlockExtension, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseHostReservation">AWS
   * API Reference</a></p>
   */
  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 <typename PurchaseHostReservationRequestT = Model::PurchaseHostReservationRequest>
  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 <typename PurchaseHostReservationRequestT = Model::PurchaseHostReservationRequest>
  void PurchaseHostReservationAsync(const PurchaseHostReservationRequestT& request,
                                    const PurchaseHostReservationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::PurchaseHostReservation, request, handler, context);
  }

  /**
   * <p>Purchases a Reserved Instance for use with your account. With Reserved
   * Instances, you pay a lower hourly rate compared to On-Demand instance
   * pricing.</p> <p>Use <a>DescribeReservedInstancesOfferings</a> 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
   * <a>DescribeReservedInstances</a>.</p> <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts-on-demand-reserved-instances.html">Reserved
   * Instances</a> and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Sell
   * in the Reserved Instance Marketplace</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseReservedInstancesOffering">AWS
   * API Reference</a></p>
   */
  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 <typename PurchaseReservedInstancesOfferingRequestT = Model::PurchaseReservedInstancesOfferingRequest>
  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 <typename PurchaseReservedInstancesOfferingRequestT = Model::PurchaseReservedInstancesOfferingRequest>
  void PurchaseReservedInstancesOfferingAsync(const PurchaseReservedInstancesOfferingRequestT& request,
                                              const PurchaseReservedInstancesOfferingResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::PurchaseReservedInstancesOffering, request, handler, context);
  }

  /**
   *  <p>You can no longer purchase Scheduled Instances.</p>
   * <p>Purchases the Scheduled Instances with the specified schedule.</p>
   * <p>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 <a>DescribeScheduledInstanceAvailability</a> to check for available
   * schedules and obtain a purchase token. After you purchase a Scheduled Instance,
   * you must call <a>RunScheduledInstances</a> during each scheduled time
   * period.</p> <p>After you purchase a Scheduled Instance, you can't cancel,
   * modify, or resell your purchase.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseScheduledInstances">AWS
   * API Reference</a></p>
   */
  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 <typename PurchaseScheduledInstancesRequestT = Model::PurchaseScheduledInstancesRequest>
  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 <typename PurchaseScheduledInstancesRequestT = Model::PurchaseScheduledInstancesRequest>
  void PurchaseScheduledInstancesAsync(const PurchaseScheduledInstancesRequestT& request,
                                       const PurchaseScheduledInstancesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::PurchaseScheduledInstances, request, handler, context);
  }

  /**
   * <p>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.</p> <p>If an instance does not cleanly shut
   * down within a few minutes, Amazon EC2 performs a hard reboot.</p> <p>For more
   * information about troubleshooting, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html">Troubleshoot
   * an unreachable instance</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RebootInstances">AWS
   * API Reference</a></p>
   */
  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 <typename RebootInstancesRequestT = Model::RebootInstancesRequest>
  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 <typename RebootInstancesRequestT = Model::RebootInstancesRequest>
  void RebootInstancesAsync(const RebootInstancesRequestT& request, const RebootInstancesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RebootInstances, request, handler, context);
  }

  /**
   * <p>Registers an AMI. When you're creating an instance-store backed AMI,
   * registering the AMI is the final step in the creation process. For more
   * information about creating AMIs, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html#creating-launching-ami-from-snapshot">Create
   * an AMI from a snapshot</a> and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-instance-store.html">Create
   * an instance-store backed AMI</a> in the <i>Amazon EC2 User Guide</i>.</p> <p>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.</p> <p> <b>Register a snapshot of a root device volume</b> </p> <p>You
   * can use <code>RegisterImage</code> 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.</p>
   * <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html#creating-launching-ami-from-snapshot">Create
   * an AMI from a snapshot</a> and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIEncryption.html">Use
   * encryption with EBS-backed AMIs</a> in the <i>Amazon EC2 User Guide</i>.</p> <p>
   * <b>Amazon Web Services Marketplace product codes</b> </p> <p>If any snapshots
   * have Amazon Web Services Marketplace product codes, they are copied to the new
   * AMI.</p> <p>In most cases, AMIs for Windows, RedHat, SUSE, and SQL Server
   * require correct licensing information to be present on the AMI. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-billing-info.html">Understand
   * AMI billing information</a> in the <i>Amazon EC2 User Guide</i>. When creating
   * an AMI from a snapshot, the <code>RegisterImage</code> operation derives the
   * correct billing information from the snapshot's metadata, but this requires the
   * appropriate metadata to be present. To verify if the correct billing information
   * was applied, check the <code>PlatformDetails</code> field on the new AMI. If the
   * field is empty or doesn't match the expected operating system code (for example,
   * Windows, RedHat, SUSE, or SQL), the AMI creation was unsuccessful, and you
   * should discard the AMI and instead create the AMI from an instance. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html#how-to-create-ebs-ami">Create
   * an AMI from an instance </a> in the <i>Amazon EC2 User Guide</i>.</p> <p>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 is not applied
   * to the On-Demand Instance. For information about how to obtain the platform
   * details and billing information of an AMI, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-billing-info.html">Understand
   * AMI billing information</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterImage">AWS
   * API Reference</a></p>
   */
  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 <typename RegisterImageRequestT = Model::RegisterImageRequest>
  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 <typename RegisterImageRequestT = Model::RegisterImageRequest>
  void RegisterImageAsync(const RegisterImageRequestT& request, const RegisterImageResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RegisterImage, request, handler, context);
  }

  /**
   * <p>Registers a set of tag keys to include in scheduled event notifications for
   * your resources. </p> <p>To remove tags, use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeregisterInstanceEventNotificationAttributes.html">DeregisterInstanceEventNotificationAttributes</a>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterInstanceEventNotificationAttributes">AWS
   * API Reference</a></p>
   */
  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 <typename RegisterInstanceEventNotificationAttributesRequestT = Model::RegisterInstanceEventNotificationAttributesRequest>
  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 <typename RegisterInstanceEventNotificationAttributesRequestT = Model::RegisterInstanceEventNotificationAttributesRequest>
  void RegisterInstanceEventNotificationAttributesAsync(
      const RegisterInstanceEventNotificationAttributesRequestT& request,
      const RegisterInstanceEventNotificationAttributesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RegisterInstanceEventNotificationAttributes, request, handler, context);
  }

  /**
   * <p>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 more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-multicast-overview.html">Multicast
   * on transit gateways</a> in the <i>Amazon Web Services Transit Gateways
   * Guide</i>.</p> <p>After you add the members, use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SearchTransitGatewayMulticastGroups.html">SearchTransitGatewayMulticastGroups</a>
   * to verify that the members were added to the transit gateway multicast
   * group.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterTransitGatewayMulticastGroupMembers">AWS
   * API Reference</a></p>
   */
  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 <typename RegisterTransitGatewayMulticastGroupMembersRequestT = Model::RegisterTransitGatewayMulticastGroupMembersRequest>
  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 <typename RegisterTransitGatewayMulticastGroupMembersRequestT = Model::RegisterTransitGatewayMulticastGroupMembersRequest>
  void RegisterTransitGatewayMulticastGroupMembersAsync(
      const RegisterTransitGatewayMulticastGroupMembersRequestT& request,
      const RegisterTransitGatewayMulticastGroupMembersResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RegisterTransitGatewayMulticastGroupMembers, request, handler, context);
  }

  /**
   * <p>Registers sources (network interfaces) with the specified transit gateway
   * multicast group.</p> <p>A multicast source is a network interface attached to a
   * supported instance that sends multicast traffic. For more information about
   * supported instances, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-multicast-overview.html">Multicast
   * on transit gateways</a> in the <i>Amazon Web Services Transit Gateways
   * Guide</i>.</p> <p>After you add the source, use <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SearchTransitGatewayMulticastGroups.html">SearchTransitGatewayMulticastGroups</a>
   * to verify that the source was added to the multicast group.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterTransitGatewayMulticastGroupSources">AWS
   * API Reference</a></p>
   */
  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 <typename RegisterTransitGatewayMulticastGroupSourcesRequestT = Model::RegisterTransitGatewayMulticastGroupSourcesRequest>
  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 <typename RegisterTransitGatewayMulticastGroupSourcesRequestT = Model::RegisterTransitGatewayMulticastGroupSourcesRequest>
  void RegisterTransitGatewayMulticastGroupSourcesAsync(
      const RegisterTransitGatewayMulticastGroupSourcesRequestT& request,
      const RegisterTransitGatewayMulticastGroupSourcesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RegisterTransitGatewayMulticastGroupSources, request, handler, context);
  }

  /**
   * <p>Rejects a request to assign billing of the available capacity of a shared
   * Capacity Reservation to your account. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/assign-billing.html">
   * Billing assignment for shared Amazon EC2 Capacity
   * Reservations</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectCapacityReservationBillingOwnership">AWS
   * API Reference</a></p>
   */
  virtual Model::RejectCapacityReservationBillingOwnershipOutcome RejectCapacityReservationBillingOwnership(
      const Model::RejectCapacityReservationBillingOwnershipRequest& request) const;

  /**
   * A Callable wrapper for RejectCapacityReservationBillingOwnership that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename RejectCapacityReservationBillingOwnershipRequestT = Model::RejectCapacityReservationBillingOwnershipRequest>
  Model::RejectCapacityReservationBillingOwnershipOutcomeCallable RejectCapacityReservationBillingOwnershipCallable(
      const RejectCapacityReservationBillingOwnershipRequestT& request) const {
    return SubmitCallable(&EC2Client::RejectCapacityReservationBillingOwnership, request);
  }

  /**
   * An Async wrapper for RejectCapacityReservationBillingOwnership that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename RejectCapacityReservationBillingOwnershipRequestT = Model::RejectCapacityReservationBillingOwnershipRequest>
  void RejectCapacityReservationBillingOwnershipAsync(
      const RejectCapacityReservationBillingOwnershipRequestT& request,
      const RejectCapacityReservationBillingOwnershipResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RejectCapacityReservationBillingOwnership, request, handler, context);
  }

  /**
   * <p>Rejects a request to associate cross-account subnets with a transit gateway
   * multicast domain.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayMulticastDomainAssociations">AWS
   * API Reference</a></p>
   */
  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 <
      typename RejectTransitGatewayMulticastDomainAssociationsRequestT = Model::RejectTransitGatewayMulticastDomainAssociationsRequest>
  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 <
      typename RejectTransitGatewayMulticastDomainAssociationsRequestT = Model::RejectTransitGatewayMulticastDomainAssociationsRequest>
  void RejectTransitGatewayMulticastDomainAssociationsAsync(
      const RejectTransitGatewayMulticastDomainAssociationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const RejectTransitGatewayMulticastDomainAssociationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::RejectTransitGatewayMulticastDomainAssociations, request, handler, context);
  }

  /**
   * <p>Rejects a transit gateway peering attachment request.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayPeeringAttachment">AWS
   * API Reference</a></p>
   */
  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 <typename RejectTransitGatewayPeeringAttachmentRequestT = Model::RejectTransitGatewayPeeringAttachmentRequest>
  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 <typename RejectTransitGatewayPeeringAttachmentRequestT = Model::RejectTransitGatewayPeeringAttachmentRequest>
  void RejectTransitGatewayPeeringAttachmentAsync(const RejectTransitGatewayPeeringAttachmentRequestT& request,
                                                  const RejectTransitGatewayPeeringAttachmentResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RejectTransitGatewayPeeringAttachment, request, handler, context);
  }

  /**
   * <p>Rejects a request to attach a VPC to a transit gateway.</p> <p>The VPC
   * attachment must be in the <code>pendingAcceptance</code> state. Use
   * <a>DescribeTransitGatewayVpcAttachments</a> to view your pending VPC attachment
   * requests. Use <a>AcceptTransitGatewayVpcAttachment</a> to accept a VPC
   * attachment request.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayVpcAttachment">AWS
   * API Reference</a></p>
   */
  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 <typename RejectTransitGatewayVpcAttachmentRequestT = Model::RejectTransitGatewayVpcAttachmentRequest>
  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 <typename RejectTransitGatewayVpcAttachmentRequestT = Model::RejectTransitGatewayVpcAttachmentRequest>
  void RejectTransitGatewayVpcAttachmentAsync(const RejectTransitGatewayVpcAttachmentRequestT& request,
                                              const RejectTransitGatewayVpcAttachmentResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RejectTransitGatewayVpcAttachment, request, handler, context);
  }

  /**
   * <p>Rejects VPC endpoint connection requests to your VPC endpoint
   * service.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectVpcEndpointConnections">AWS
   * API Reference</a></p>
   */
  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 <typename RejectVpcEndpointConnectionsRequestT = Model::RejectVpcEndpointConnectionsRequest>
  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 <typename RejectVpcEndpointConnectionsRequestT = Model::RejectVpcEndpointConnectionsRequest>
  void RejectVpcEndpointConnectionsAsync(const RejectVpcEndpointConnectionsRequestT& request,
                                         const RejectVpcEndpointConnectionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RejectVpcEndpointConnections, request, handler, context);
  }

  /**
   * <p>Rejects a VPC peering connection request. The VPC peering connection must be
   * in the <code>pending-acceptance</code> state. Use the
   * <a>DescribeVpcPeeringConnections</a> 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
   * <a>DeleteVpcPeeringConnection</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectVpcPeeringConnection">AWS
   * API Reference</a></p>
   */
  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 <typename RejectVpcPeeringConnectionRequestT = Model::RejectVpcPeeringConnectionRequest>
  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 <typename RejectVpcPeeringConnectionRequestT = Model::RejectVpcPeeringConnectionRequest>
  void RejectVpcPeeringConnectionAsync(const RejectVpcPeeringConnectionRequestT& request,
                                       const RejectVpcPeeringConnectionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RejectVpcPeeringConnection, request, handler, context);
  }

  /**
   * <p>Releases the specified Elastic IP address.</p> <p>[Default VPC] Releasing an
   * Elastic IP address automatically disassociates it from any instance that it's
   * associated with. Alternatively, you can disassociate an Elastic IP address
   * without releasing it.</p> <p>[Nondefault VPC] You must disassociate the Elastic
   * IP address before you can release it. Otherwise, Amazon EC2 returns an error
   * (<code>InvalidIPAddress.InUse</code>).</p> <p>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 <code>AuthFailure</code> error if the address is already allocated to another
   * Amazon Web Services account.</p> <p>After you release an Elastic IP address, you
   * might be able to recover it. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing-eips-releasing.html">Release
   * an Elastic IP address</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseAddress">AWS
   * API Reference</a></p>
   */
  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 <typename ReleaseAddressRequestT = Model::ReleaseAddressRequest>
  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 <typename ReleaseAddressRequestT = Model::ReleaseAddressRequest>
  void ReleaseAddressAsync(const ReleaseAddressResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ReleaseAddressRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ReleaseAddress, request, handler, context);
  }

  /**
   * <p>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
   * <code>released</code> 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.</p> <p>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.</p> <p>Released hosts still appear in a <a>DescribeHosts</a>
   * response.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseHosts">AWS
   * API Reference</a></p>
   */
  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 <typename ReleaseHostsRequestT = Model::ReleaseHostsRequest>
  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 <typename ReleaseHostsRequestT = Model::ReleaseHostsRequest>
  void ReleaseHostsAsync(const ReleaseHostsRequestT& request, const ReleaseHostsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReleaseHosts, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyIpamResourceCidr.html">ModifyIpamResourceCidr</a>.
   * For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/ipam/release-alloc-ipam.html">Release
   * an allocation</a> in the <i>Amazon VPC IPAM User Guide</i>. </p>  <p>All
   * EC2 API actions follow an <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/eventual-consistency.html">eventual
   * consistency</a> model.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseIpamPoolAllocation">AWS
   * API Reference</a></p>
   */
  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 <typename ReleaseIpamPoolAllocationRequestT = Model::ReleaseIpamPoolAllocationRequest>
  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 <typename ReleaseIpamPoolAllocationRequestT = Model::ReleaseIpamPoolAllocationRequest>
  void ReleaseIpamPoolAllocationAsync(const ReleaseIpamPoolAllocationRequestT& request,
                                      const ReleaseIpamPoolAllocationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReleaseIpamPoolAllocation, request, handler, context);
  }

  /**
   * <p>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.</p> <p>Use <a>DescribeIamInstanceProfileAssociations</a> to get the
   * association ID.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceIamInstanceProfileAssociation">AWS
   * API Reference</a></p>
   */
  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 <typename ReplaceIamInstanceProfileAssociationRequestT = Model::ReplaceIamInstanceProfileAssociationRequest>
  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 <typename ReplaceIamInstanceProfileAssociationRequestT = Model::ReplaceIamInstanceProfileAssociationRequest>
  void ReplaceIamInstanceProfileAssociationAsync(const ReplaceIamInstanceProfileAssociationRequestT& request,
                                                 const ReplaceIamInstanceProfileAssociationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReplaceIamInstanceProfileAssociation, request, handler, context);
  }

  /**
   * <p>Sets or replaces the criteria for Allowed AMIs.</p>  <p>The Allowed
   * AMIs feature does not restrict the AMIs owned by your account. Regardless of the
   * criteria you set, the AMIs created by your account will always be discoverable
   * and usable by users in your account.</p>  <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-allowed-amis.html">Control
   * the discovery and use of AMIs in Amazon EC2 with Allowed AMIs</a> in <i>Amazon
   * EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceImageCriteriaInAllowedImagesSettings">AWS
   * API Reference</a></p>
   */
  virtual Model::ReplaceImageCriteriaInAllowedImagesSettingsOutcome ReplaceImageCriteriaInAllowedImagesSettings(
      const Model::ReplaceImageCriteriaInAllowedImagesSettingsRequest& request = {}) const;

  /**
   * A Callable wrapper for ReplaceImageCriteriaInAllowedImagesSettings that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename ReplaceImageCriteriaInAllowedImagesSettingsRequestT = Model::ReplaceImageCriteriaInAllowedImagesSettingsRequest>
  Model::ReplaceImageCriteriaInAllowedImagesSettingsOutcomeCallable ReplaceImageCriteriaInAllowedImagesSettingsCallable(
      const ReplaceImageCriteriaInAllowedImagesSettingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ReplaceImageCriteriaInAllowedImagesSettings, request);
  }

  /**
   * An Async wrapper for ReplaceImageCriteriaInAllowedImagesSettings that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename ReplaceImageCriteriaInAllowedImagesSettingsRequestT = Model::ReplaceImageCriteriaInAllowedImagesSettingsRequest>
  void ReplaceImageCriteriaInAllowedImagesSettingsAsync(const ReplaceImageCriteriaInAllowedImagesSettingsResponseReceivedHandler& handler,
                                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                        const ReplaceImageCriteriaInAllowedImagesSettingsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ReplaceImageCriteriaInAllowedImagesSettings, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
   * ACLs</a> in the <i>Amazon VPC User Guide</i>.</p> <p>This is an idempotent
   * operation.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceNetworkAclAssociation">AWS
   * API Reference</a></p>
   */
  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 <typename ReplaceNetworkAclAssociationRequestT = Model::ReplaceNetworkAclAssociationRequest>
  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 <typename ReplaceNetworkAclAssociationRequestT = Model::ReplaceNetworkAclAssociationRequest>
  void ReplaceNetworkAclAssociationAsync(const ReplaceNetworkAclAssociationRequestT& request,
                                         const ReplaceNetworkAclAssociationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReplaceNetworkAclAssociation, request, handler, context);
  }

  /**
   * <p>Replaces an entry (rule) in a network ACL. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
   * ACLs</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceNetworkAclEntry">AWS
   * API Reference</a></p>
   */
  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 <typename ReplaceNetworkAclEntryRequestT = Model::ReplaceNetworkAclEntryRequest>
  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 <typename ReplaceNetworkAclEntryRequestT = Model::ReplaceNetworkAclEntryRequest>
  void ReplaceNetworkAclEntryAsync(const ReplaceNetworkAclEntryRequestT& request,
                                   const ReplaceNetworkAclEntryResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReplaceNetworkAclEntry, request, handler, context);
  }

  /**
   * <p>Replaces an existing route within a route table in a VPC.</p> <p>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.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
   * tables</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceRoute">AWS
   * API Reference</a></p>
   */
  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 <typename ReplaceRouteRequestT = Model::ReplaceRouteRequest>
  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 <typename ReplaceRouteRequestT = Model::ReplaceRouteRequest>
  void ReplaceRouteAsync(const ReplaceRouteRequestT& request, const ReplaceRouteResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReplaceRoute, request, handler, context);
  }

  /**
   * <p>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 <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
   * tables</a> in the <i>Amazon VPC User Guide</i>.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceRouteTableAssociation">AWS
   * API Reference</a></p>
   */
  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 <typename ReplaceRouteTableAssociationRequestT = Model::ReplaceRouteTableAssociationRequest>
  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 <typename ReplaceRouteTableAssociationRequestT = Model::ReplaceRouteTableAssociationRequest>
  void ReplaceRouteTableAssociationAsync(const ReplaceRouteTableAssociationRequestT& request,
                                         const ReplaceRouteTableAssociationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReplaceRouteTableAssociation, request, handler, context);
  }

  /**
   * <p>Replaces the specified route in the specified transit gateway route
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceTransitGatewayRoute">AWS
   * API Reference</a></p>
   */
  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 <typename ReplaceTransitGatewayRouteRequestT = Model::ReplaceTransitGatewayRouteRequest>
  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 <typename ReplaceTransitGatewayRouteRequestT = Model::ReplaceTransitGatewayRouteRequest>
  void ReplaceTransitGatewayRouteAsync(const ReplaceTransitGatewayRouteRequestT& request,
                                       const ReplaceTransitGatewayRouteResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReplaceTransitGatewayRoute, request, handler, context);
  }

  /**
   * <p>Trigger replacement of specified VPN tunnel.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceVpnTunnel">AWS
   * API Reference</a></p>
   */
  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 <typename ReplaceVpnTunnelRequestT = Model::ReplaceVpnTunnelRequest>
  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 <typename ReplaceVpnTunnelRequestT = Model::ReplaceVpnTunnelRequest>
  void ReplaceVpnTunnelAsync(const ReplaceVpnTunnelRequestT& request, const ReplaceVpnTunnelResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReplaceVpnTunnel, request, handler, context);
  }

  /**
   * <p>Submits feedback about the status of an instance. The instance must be in the
   * <code>running</code> state. If your experience with the instance differs from
   * the instance status returned by <a>DescribeInstanceStatus</a>, use
   * <a>ReportInstanceStatus</a> to report your experience with the instance. Amazon
   * EC2 collects this information to improve the accuracy of status checks.</p>
   * <p>Use of this action does not change the value returned by
   * <a>DescribeInstanceStatus</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReportInstanceStatus">AWS
   * API Reference</a></p>
   */
  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 <typename ReportInstanceStatusRequestT = Model::ReportInstanceStatusRequest>
  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 <typename ReportInstanceStatusRequestT = Model::ReportInstanceStatusRequest>
  void ReportInstanceStatusAsync(const ReportInstanceStatusRequestT& request, const ReportInstanceStatusResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ReportInstanceStatus, request, handler, context);
  }

  /**
   * <p>Creates a Spot Fleet request.</p> <p>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.</p> <p>You can submit a single request that
   * includes multiple launch specifications that vary by instance type, AMI,
   * Availability Zone, or subnet.</p> <p>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.</p> <p>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.</p> <p>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 <code>spot-fleet-request</code> and
   * <code>instance</code> resource types are supported.</p> <p>For more information,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-requests.html">Spot
   * Fleet requests</a> in the <i>Amazon EC2 User Guide</i>.</p>  <p>We
   * strongly discourage using the RequestSpotFleet API because it is a legacy API
   * with no planned investment. For options for requesting Spot Instances, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-best-practices.html#which-spot-request-method-to-use">Which
   * is the best Spot request method to use?</a> in the <i>Amazon EC2 User
   * Guide</i>.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RequestSpotFleet">AWS
   * API Reference</a></p>
   */
  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 <typename RequestSpotFleetRequestT = Model::RequestSpotFleetRequest>
  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 <typename RequestSpotFleetRequestT = Model::RequestSpotFleetRequest>
  void RequestSpotFleetAsync(const RequestSpotFleetRequestT& request, const RequestSpotFleetResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RequestSpotFleet, request, handler, context);
  }

  /**
   * <p>Creates a Spot Instance request.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html">Work
   * with Spot Instance</a> in the <i>Amazon EC2 User Guide</i>.</p>
   * <p>We strongly discourage using the RequestSpotInstances API because it is a
   * legacy API with no planned investment. For options for requesting Spot
   * Instances, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-best-practices.html#which-spot-request-method-to-use">Which
   * is the best Spot request method to use?</a> in the <i>Amazon EC2 User
   * Guide</i>.</p> <p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RequestSpotInstances">AWS
   * API Reference</a></p>
   */
  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 <typename RequestSpotInstancesRequestT = Model::RequestSpotInstancesRequest>
  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 <typename RequestSpotInstancesRequestT = Model::RequestSpotInstancesRequest>
  void RequestSpotInstancesAsync(const RequestSpotInstancesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const RequestSpotInstancesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::RequestSpotInstances, request, handler, context);
  }

  /**
   * <p>Resets the attribute of the specified IP address. For requirements, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html#Using_Elastic_Addressing_Reverse_DNS">Using
   * reverse DNS for email applications</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetAddressAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ResetAddressAttributeRequestT = Model::ResetAddressAttributeRequest>
  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 <typename ResetAddressAttributeRequestT = Model::ResetAddressAttributeRequest>
  void ResetAddressAttributeAsync(const ResetAddressAttributeRequestT& request, const ResetAddressAttributeResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ResetAddressAttribute, request, handler, context);
  }

  /**
   * <p>Resets the default KMS key for EBS encryption for your account in this Region
   * to the Amazon Web Services managed KMS key for EBS.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html">Amazon
   * EBS encryption</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetEbsDefaultKmsKeyId">AWS
   * API Reference</a></p>
   */
  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 <typename ResetEbsDefaultKmsKeyIdRequestT = Model::ResetEbsDefaultKmsKeyIdRequest>
  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 <typename ResetEbsDefaultKmsKeyIdRequestT = Model::ResetEbsDefaultKmsKeyIdRequest>
  void ResetEbsDefaultKmsKeyIdAsync(const ResetEbsDefaultKmsKeyIdResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ResetEbsDefaultKmsKeyIdRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ResetEbsDefaultKmsKeyId, request, handler, context);
  }

  /**
   * <p>Resets the specified attribute of the specified Amazon FPGA Image (AFI) to
   * its default value. You can only reset the load permission
   * attribute.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetFpgaImageAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ResetFpgaImageAttributeRequestT = Model::ResetFpgaImageAttributeRequest>
  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 <typename ResetFpgaImageAttributeRequestT = Model::ResetFpgaImageAttributeRequest>
  void ResetFpgaImageAttributeAsync(const ResetFpgaImageAttributeRequestT& request,
                                    const ResetFpgaImageAttributeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ResetFpgaImageAttribute, request, handler, context);
  }

  /**
   * <p>Resets an attribute of an AMI to its default value.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetImageAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ResetImageAttributeRequestT = Model::ResetImageAttributeRequest>
  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 <typename ResetImageAttributeRequestT = Model::ResetImageAttributeRequest>
  void ResetImageAttributeAsync(const ResetImageAttributeRequestT& request, const ResetImageAttributeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ResetImageAttribute, request, handler, context);
  }

  /**
   * <p>Resets an attribute of an instance to its default value. To reset the
   * <code>kernel</code> or <code>ramdisk</code>, the instance must be in a stopped
   * state. To reset the <code>sourceDestCheck</code>, the instance can be either
   * running or stopped.</p> <p>The <code>sourceDestCheck</code> attribute controls
   * whether source/destination checking is enabled. The default value is
   * <code>true</code>, which means checking is enabled. This value must be
   * <code>false</code> for a NAT instance to perform NAT. For more information, see
   * <a
   * href="https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html">NAT
   * instances</a> in the <i>Amazon VPC User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetInstanceAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ResetInstanceAttributeRequestT = Model::ResetInstanceAttributeRequest>
  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 <typename ResetInstanceAttributeRequestT = Model::ResetInstanceAttributeRequest>
  void ResetInstanceAttributeAsync(const ResetInstanceAttributeRequestT& request,
                                   const ResetInstanceAttributeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ResetInstanceAttribute, request, handler, context);
  }

  /**
   * <p>Resets a network interface attribute. You can specify only one attribute at a
   * time.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetNetworkInterfaceAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ResetNetworkInterfaceAttributeRequestT = Model::ResetNetworkInterfaceAttributeRequest>
  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 <typename ResetNetworkInterfaceAttributeRequestT = Model::ResetNetworkInterfaceAttributeRequest>
  void ResetNetworkInterfaceAttributeAsync(const ResetNetworkInterfaceAttributeRequestT& request,
                                           const ResetNetworkInterfaceAttributeResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ResetNetworkInterfaceAttribute, request, handler, context);
  }

  /**
   * <p>Resets permission settings for the specified snapshot.</p> <p>For more
   * information about modifying snapshot permissions, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modifying-snapshot-permissions.html">Share
   * a snapshot</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetSnapshotAttribute">AWS
   * API Reference</a></p>
   */
  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 <typename ResetSnapshotAttributeRequestT = Model::ResetSnapshotAttributeRequest>
  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 <typename ResetSnapshotAttributeRequestT = Model::ResetSnapshotAttributeRequest>
  void ResetSnapshotAttributeAsync(const ResetSnapshotAttributeRequestT& request,
                                   const ResetSnapshotAttributeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ResetSnapshotAttribute, request, handler, context);
  }

  /**
   *  <p>This action is deprecated.</p>  <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreAddressToClassic">AWS
   * API Reference</a></p>
   */
  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 <typename RestoreAddressToClassicRequestT = Model::RestoreAddressToClassicRequest>
  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 <typename RestoreAddressToClassicRequestT = Model::RestoreAddressToClassicRequest>
  void RestoreAddressToClassicAsync(const RestoreAddressToClassicRequestT& request,
                                    const RestoreAddressToClassicResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RestoreAddressToClassic, request, handler, context);
  }

  /**
   * <p>Restores an AMI from the Recycle Bin. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin.html">Recover
   * deleted Amazon EBS snapshots and EBS-back AMIs with Recycle Bin</a> in the
   * <i>Amazon EC2 User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreImageFromRecycleBin">AWS
   * API Reference</a></p>
   */
  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 <typename RestoreImageFromRecycleBinRequestT = Model::RestoreImageFromRecycleBinRequest>
  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 <typename RestoreImageFromRecycleBinRequestT = Model::RestoreImageFromRecycleBinRequest>
  void RestoreImageFromRecycleBinAsync(const RestoreImageFromRecycleBinRequestT& request,
                                       const RestoreImageFromRecycleBinResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RestoreImageFromRecycleBin, request, handler, context);
  }

  /**
   * <p>Restores the entries from a previous version of a managed prefix list to a
   * new version of the prefix list.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreManagedPrefixListVersion">AWS
   * API Reference</a></p>
   */
  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 <typename RestoreManagedPrefixListVersionRequestT = Model::RestoreManagedPrefixListVersionRequest>
  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 <typename RestoreManagedPrefixListVersionRequestT = Model::RestoreManagedPrefixListVersionRequest>
  void RestoreManagedPrefixListVersionAsync(const RestoreManagedPrefixListVersionRequestT& request,
                                            const RestoreManagedPrefixListVersionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RestoreManagedPrefixListVersion, request, handler, context);
  }

  /**
   * <p>Restores a snapshot from the Recycle Bin. For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-snaps.html#recycle-bin-restore-snaps">Restore
   * snapshots from the Recycle Bin</a> in the <i>Amazon EBS User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreSnapshotFromRecycleBin">AWS
   * API Reference</a></p>
   */
  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 <typename RestoreSnapshotFromRecycleBinRequestT = Model::RestoreSnapshotFromRecycleBinRequest>
  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 <typename RestoreSnapshotFromRecycleBinRequestT = Model::RestoreSnapshotFromRecycleBinRequest>
  void RestoreSnapshotFromRecycleBinAsync(const RestoreSnapshotFromRecycleBinRequestT& request,
                                          const RestoreSnapshotFromRecycleBinResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RestoreSnapshotFromRecycleBin, request, handler, context);
  }

  /**
   * <p>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.</p> <p>For more information see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/working-with-snapshot-archiving.html#restore-archived-snapshot">
   * Restore an archived snapshot</a> and <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/working-with-snapshot-archiving.html#modify-temp-restore-period">
   * modify the restore period or restore type for a temporarily restored
   * snapshot</a> in the <i>Amazon EBS User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreSnapshotTier">AWS
   * API Reference</a></p>
   */
  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 <typename RestoreSnapshotTierRequestT = Model::RestoreSnapshotTierRequest>
  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 <typename RestoreSnapshotTierRequestT = Model::RestoreSnapshotTierRequest>
  void RestoreSnapshotTierAsync(const RestoreSnapshotTierRequestT& request, const RestoreSnapshotTierResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RestoreSnapshotTier, request, handler, context);
  }

  /**
   * <p>Restores a volume from the Recycle Bin. For more information, see <a
   * href="https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin-working-with-volumes.html#recycle-bin-restore-volumes">Restore
   * volumes from the Recycle Bin</a> in the <i>Amazon EBS User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreVolumeFromRecycleBin">AWS
   * API Reference</a></p>
   */
  virtual Model::RestoreVolumeFromRecycleBinOutcome RestoreVolumeFromRecycleBin(
      const Model::RestoreVolumeFromRecycleBinRequest& request) const;

  /**
   * A Callable wrapper for RestoreVolumeFromRecycleBin that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename RestoreVolumeFromRecycleBinRequestT = Model::RestoreVolumeFromRecycleBinRequest>
  Model::RestoreVolumeFromRecycleBinOutcomeCallable RestoreVolumeFromRecycleBinCallable(
      const RestoreVolumeFromRecycleBinRequestT& request) const {
    return SubmitCallable(&EC2Client::RestoreVolumeFromRecycleBin, request);
  }

  /**
   * An Async wrapper for RestoreVolumeFromRecycleBin that queues the request into a thread executor and triggers associated callback when
   * operation has finished.
   */
  template <typename RestoreVolumeFromRecycleBinRequestT = Model::RestoreVolumeFromRecycleBinRequest>
  void RestoreVolumeFromRecycleBinAsync(const RestoreVolumeFromRecycleBinRequestT& request,
                                        const RestoreVolumeFromRecycleBinResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RestoreVolumeFromRecycleBin, request, handler, context);
  }

  /**
   * <p>Removes an ingress authorization rule from a Client VPN endpoint.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeClientVpnIngress">AWS
   * API Reference</a></p>
   */
  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 <typename RevokeClientVpnIngressRequestT = Model::RevokeClientVpnIngressRequest>
  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 <typename RevokeClientVpnIngressRequestT = Model::RevokeClientVpnIngressRequest>
  void RevokeClientVpnIngressAsync(const RevokeClientVpnIngressRequestT& request,
                                   const RevokeClientVpnIngressResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RevokeClientVpnIngress, request, handler, context);
  }

  /**
   * <p>Removes the specified outbound (egress) rules from the specified security
   * group.</p> <p>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.</p> <p>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.</p> <p>Amazon Web Services recommends that you describe the security
   * group to verify that the rules were removed.</p> <p>Rule changes are propagated
   * to instances within the security group as quickly as possible. However, a small
   * delay might occur.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeSecurityGroupEgress">AWS
   * API Reference</a></p>
   */
  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 <typename RevokeSecurityGroupEgressRequestT = Model::RevokeSecurityGroupEgressRequest>
  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 <typename RevokeSecurityGroupEgressRequestT = Model::RevokeSecurityGroupEgressRequest>
  void RevokeSecurityGroupEgressAsync(const RevokeSecurityGroupEgressRequestT& request,
                                      const RevokeSecurityGroupEgressResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RevokeSecurityGroupEgress, request, handler, context);
  }

  /**
   * <p>Removes the specified inbound (ingress) rules from a security group.</p>
   * <p>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.</p> <p>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.</p> <p>For a non-default VPC, if the values you specify do not match
   * the existing rule's values, an <code>InvalidPermission.NotFound</code> client
   * error is returned, and no rules are revoked.</p> <p>Amazon Web Services
   * recommends that you describe the security group to verify that the rules were
   * removed.</p> <p>Rule changes are propagated to instances within the security
   * group as quickly as possible. However, a small delay might occur.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeSecurityGroupIngress">AWS
   * API Reference</a></p>
   */
  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 <typename RevokeSecurityGroupIngressRequestT = Model::RevokeSecurityGroupIngressRequest>
  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 <typename RevokeSecurityGroupIngressRequestT = Model::RevokeSecurityGroupIngressRequest>
  void RevokeSecurityGroupIngressAsync(const RevokeSecurityGroupIngressResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const RevokeSecurityGroupIngressRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::RevokeSecurityGroupIngress, request, handler, context);
  }

  /**
   * <p>Launches the specified number of instances using an AMI for which you have
   * permissions.</p> <p>You can specify a number of options, or leave the default
   * options. The following rules apply:</p> <ul> <li> <p>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.</p> </li>
   * <li> <p>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.</p> </li> <li> <p>Not all instance types support IPv6 addresses.
   * For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html">Instance
   * types</a>.</p> </li> <li> <p>If you don't specify a security group ID, we use
   * the default security group for the VPC. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Security
   * groups</a>.</p> </li> <li> <p>If any of the AMIs have a product code attached
   * for which the user has not subscribed, the request fails.</p> </li> </ul> <p>You
   * can create a <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">launch
   * template</a>, which is a resource that contains the parameters to launch an
   * instance. When you launch an instance using <a>RunInstances</a>, you can specify
   * the launch template instead of specifying the launch parameters.</p> <p>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.</p> <p> <code>RunInstances</code> is
   * subject to both request rate limiting and resource rate limiting. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-throttling.html">Request
   * throttling</a>.</p> <p>An instance is ready for you to use when it's in the
   * <code>running</code> state. You can check the state of your instance using
   * <a>DescribeInstances</a>. You can tag instances and EBS volumes during launch,
   * after launch, or both. For more information, see <a>CreateTags</a> and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tagging
   * your Amazon EC2 resources</a>.</p> <p>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 <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Key
   * pairs</a>.</p> <p>For troubleshooting, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_InstanceStraightToTerminated.html">What
   * to do if an instance immediately terminates</a>, and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html">Troubleshooting
   * connecting to your instance</a>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RunInstances">AWS
   * API Reference</a></p>
   */
  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 <typename RunInstancesRequestT = Model::RunInstancesRequest>
  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 <typename RunInstancesRequestT = Model::RunInstancesRequest>
  void RunInstancesAsync(const RunInstancesRequestT& request, const RunInstancesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RunInstances, request, handler, context);
  }

  /**
   * <p>Launches the specified Scheduled Instances.</p> <p>Before you can launch a
   * Scheduled Instance, you must purchase it and obtain an identifier using
   * <a>PurchaseScheduledInstances</a>.</p> <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RunScheduledInstances">AWS
   * API Reference</a></p>
   */
  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 <typename RunScheduledInstancesRequestT = Model::RunScheduledInstancesRequest>
  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 <typename RunScheduledInstancesRequestT = Model::RunScheduledInstancesRequest>
  void RunScheduledInstancesAsync(const RunScheduledInstancesRequestT& request, const RunScheduledInstancesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RunScheduledInstances, request, handler, context);
  }

  /**
   * <p>Searches for routes in the specified local gateway route table.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchLocalGatewayRoutes">AWS
   * API Reference</a></p>
   */
  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 <typename SearchLocalGatewayRoutesRequestT = Model::SearchLocalGatewayRoutesRequest>
  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 <typename SearchLocalGatewayRoutesRequestT = Model::SearchLocalGatewayRoutesRequest>
  void SearchLocalGatewayRoutesAsync(const SearchLocalGatewayRoutesRequestT& request,
                                     const SearchLocalGatewayRoutesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::SearchLocalGatewayRoutes, request, handler, context);
  }

  /**
   * <p>Searches one or more transit gateway multicast groups and returns the group
   * membership information.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchTransitGatewayMulticastGroups">AWS
   * API Reference</a></p>
   */
  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 <typename SearchTransitGatewayMulticastGroupsRequestT = Model::SearchTransitGatewayMulticastGroupsRequest>
  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 <typename SearchTransitGatewayMulticastGroupsRequestT = Model::SearchTransitGatewayMulticastGroupsRequest>
  void SearchTransitGatewayMulticastGroupsAsync(const SearchTransitGatewayMulticastGroupsRequestT& request,
                                                const SearchTransitGatewayMulticastGroupsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::SearchTransitGatewayMulticastGroups, request, handler, context);
  }

  /**
   * <p>Searches for routes in the specified transit gateway route
   * table.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchTransitGatewayRoutes">AWS
   * API Reference</a></p>
   */
  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 <typename SearchTransitGatewayRoutesRequestT = Model::SearchTransitGatewayRoutesRequest>
  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 <typename SearchTransitGatewayRoutesRequestT = Model::SearchTransitGatewayRoutesRequest>
  void SearchTransitGatewayRoutesAsync(const SearchTransitGatewayRoutesRequestT& request,
                                       const SearchTransitGatewayRoutesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::SearchTransitGatewayRoutes, request, handler, context);
  }

  /**
   * <p>Sends a diagnostic interrupt to the specified Amazon EC2 instance to trigger
   * a <i>kernel panic</i> (on Linux instances), or a <i>blue screen</i>/<i>stop
   * error</i> (on Windows instances). For instances based on Intel and AMD
   * processors, the interrupt is received as a <i>non-maskable interrupt</i>
   * (NMI).</p> <p>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.</p> <p>Before sending a diagnostic
   * interrupt to your instance, ensure that its operating system is configured to
   * perform the required diagnostic tasks.</p> <p>For more information about
   * configuring your operating system to generate a crash dump when a kernel panic
   * or stop error occurs, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/diagnostic-interrupt.html">Send
   * a diagnostic interrupt (for advanced users)</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SendDiagnosticInterrupt">AWS
   * API Reference</a></p>
   */
  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 <typename SendDiagnosticInterruptRequestT = Model::SendDiagnosticInterruptRequest>
  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 <typename SendDiagnosticInterruptRequestT = Model::SendDiagnosticInterruptRequest>
  void SendDiagnosticInterruptAsync(const SendDiagnosticInterruptRequestT& request,
                                    const SendDiagnosticInterruptResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::SendDiagnosticInterrupt, request, handler, context);
  }

  /**
   * <p>Generates an account status report. The report is generated asynchronously,
   * and can take several hours to complete.</p> <p>The report provides the current
   * status of all attributes supported by declarative policies for the accounts
   * within the specified scope. The scope is determined by the specified
   * <code>TargetId</code>, which can represent an individual account, or all the
   * accounts that fall under the specified organizational unit (OU) or root (the
   * entire Amazon Web Services Organization).</p> <p>The report is saved to your
   * specified S3 bucket, using the following path structure (with the capitalized
   * placeholders representing your specific values):</p> <p>
   * <code>s3://AMZN-S3-DEMO-BUCKET/YOUR-OPTIONAL-S3-PREFIX/ec2_TARGETID_REPORTID_YYYYMMDDTHHMMZ.csv</code>
   * </p> <p class="title"> <b>Prerequisites for generating a report</b> </p> <ul>
   * <li> <p>The <code>StartDeclarativePoliciesReport</code> API can only be called
   * by the management account or delegated administrators for the organization.</p>
   * </li> <li> <p>An S3 bucket must be available before generating the report (you
   * can create a new one or use an existing one), it must be in the same Region
   * where the report generation request is made, and it must have an appropriate
   * bucket policy. For a sample S3 policy, see <i>Sample Amazon S3 policy</i> under
   * <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartDeclarativePoliciesReport.html#API_StartDeclarativePoliciesReport_Examples">Examples</a>.</p>
   * </li> <li> <p>Trusted access must be enabled for the service for which the
   * declarative policy will enforce a baseline configuration. If you use the Amazon
   * Web Services Organizations console, this is done automatically when you enable
   * declarative policies. The API uses the following service principal to identify
   * the EC2 service: <code>ec2.amazonaws.com</code>. For more information on how to
   * enable trusted access with the Amazon Web Services CLI and Amazon Web Services
   * SDKs, see <a
   * href="https://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services.html">Using
   * Organizations with other Amazon Web Services services</a> in the <i>Amazon Web
   * Services Organizations User Guide</i>.</p> </li> <li> <p>Only one report per
   * organization can be generated at a time. Attempting to generate a report while
   * another is in progress will result in an error.</p> </li> </ul> <p>For more
   * information, including the required IAM permissions to run this API, see <a
   * href="https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_declarative_status-report.html">Generating
   * the account status report for declarative policies</a> in the <i>Amazon Web
   * Services Organizations User Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartDeclarativePoliciesReport">AWS
   * API Reference</a></p>
   */
  virtual Model::StartDeclarativePoliciesReportOutcome StartDeclarativePoliciesReport(
      const Model::StartDeclarativePoliciesReportRequest& request) const;

  /**
   * A Callable wrapper for StartDeclarativePoliciesReport that returns a future to the operation so that it can be executed in parallel to
   * other requests.
   */
  template <typename StartDeclarativePoliciesReportRequestT = Model::StartDeclarativePoliciesReportRequest>
  Model::StartDeclarativePoliciesReportOutcomeCallable StartDeclarativePoliciesReportCallable(
      const StartDeclarativePoliciesReportRequestT& request) const {
    return SubmitCallable(&EC2Client::StartDeclarativePoliciesReport, request);
  }

  /**
   * An Async wrapper for StartDeclarativePoliciesReport that queues the request into a thread executor and triggers associated callback
   * when operation has finished.
   */
  template <typename StartDeclarativePoliciesReportRequestT = Model::StartDeclarativePoliciesReportRequest>
  void StartDeclarativePoliciesReportAsync(const StartDeclarativePoliciesReportRequestT& request,
                                           const StartDeclarativePoliciesReportResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::StartDeclarativePoliciesReport, request, handler, context);
  }

  /**
   * <p>Starts an Amazon EBS-backed instance that you've previously stopped.</p>
   * <p>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.</p>
   * <p>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.</p>
   * <p>Performing this operation on an instance that uses an instance store as its
   * root device returns an error.</p> <p>If you attempt to start a T3 instance with
   * <code>host</code> tenancy and the <code>unlimited</code> CPU credit option, the
   * request fails. The <code>unlimited</code> CPU credit option is not supported on
   * Dedicated Hosts. Before you start the instance, either change its CPU credit
   * option to <code>standard</code>, or change its tenancy to <code>default</code>
   * or <code>dedicated</code>.</p> <p>For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html">Stop
   * and start Amazon EC2 instances</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartInstances">AWS
   * API Reference</a></p>
   */
  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 <typename StartInstancesRequestT = Model::StartInstancesRequest>
  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 <typename StartInstancesRequestT = Model::StartInstancesRequest>
  void StartInstancesAsync(const StartInstancesRequestT& request, const StartInstancesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::StartInstances, request, handler, context);
  }

  /**
   * <p>Starts analyzing the specified Network Access Scope.</p><p><h3>See Also:</h3>
   * <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartNetworkInsightsAccessScopeAnalysis">AWS
   * API Reference</a></p>
   */
  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 <typename StartNetworkInsightsAccessScopeAnalysisRequestT = Model::StartNetworkInsightsAccessScopeAnalysisRequest>
  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 <typename StartNetworkInsightsAccessScopeAnalysisRequestT = Model::StartNetworkInsightsAccessScopeAnalysisRequest>
  void StartNetworkInsightsAccessScopeAnalysisAsync(const StartNetworkInsightsAccessScopeAnalysisRequestT& request,
                                                    const StartNetworkInsightsAccessScopeAnalysisResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::StartNetworkInsightsAccessScopeAnalysis, request, handler, context);
  }

  /**
   * <p>Starts analyzing the specified path. If the path is reachable, the operation
   * returns the shortest feasible path.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartNetworkInsightsAnalysis">AWS
   * API Reference</a></p>
   */
  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 <typename StartNetworkInsightsAnalysisRequestT = Model::StartNetworkInsightsAnalysisRequest>
  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 <typename StartNetworkInsightsAnalysisRequestT = Model::StartNetworkInsightsAnalysisRequest>
  void StartNetworkInsightsAnalysisAsync(const StartNetworkInsightsAnalysisRequestT& request,
                                         const StartNetworkInsightsAnalysisResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::StartNetworkInsightsAnalysis, request, handler, context);
  }

  /**
   * <p>Initiates the verification process to prove that the service provider owns
   * the private DNS name domain for the endpoint service.</p> <p>The service
   * provider must successfully perform the verification before the consumer can use
   * the name to access the service.</p> <p>Before the service provider runs this
   * command, they must add a record to the DNS server.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartVpcEndpointServicePrivateDnsVerification">AWS
   * API Reference</a></p>
   */
  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 <typename StartVpcEndpointServicePrivateDnsVerificationRequestT = Model::StartVpcEndpointServicePrivateDnsVerificationRequest>
  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 <typename StartVpcEndpointServicePrivateDnsVerificationRequestT = Model::StartVpcEndpointServicePrivateDnsVerificationRequest>
  void StartVpcEndpointServicePrivateDnsVerificationAsync(
      const StartVpcEndpointServicePrivateDnsVerificationRequestT& request,
      const StartVpcEndpointServicePrivateDnsVerificationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::StartVpcEndpointServicePrivateDnsVerification, request, handler, context);
  }

  /**
   * <p>Stops an Amazon EBS-backed instance. You can restart your instance at any
   * time using the <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html">StartInstances</a>
   * API. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html">Stop
   * and start Amazon EC2 instances</a> in the <i>Amazon EC2 User Guide</i>.</p>
   * <p>When you stop or hibernate an instance, we shut it down. By default, this
   * includes a graceful operating system (OS) shutdown. To bypass the graceful
   * shutdown, use the <code>skipOsShutdown</code> parameter; however, this might
   * risk data integrity.</p> <p>You can use the StopInstances operation together
   * with the <code>Hibernate</code> parameter to hibernate an instance if the
   * instance is <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/enabling-hibernation.html">enabled
   * for hibernation</a> and meets the <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/hibernating-prerequisites.html">hibernation
   * prerequisites</a>. Stopping an instance doesn't preserve data stored in RAM,
   * while hibernation does. If hibernation fails, a normal shutdown occurs. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html">Hibernate
   * your Amazon EC2 instance</a> in the <i>Amazon EC2 User Guide</i>.</p> <p>If your
   * instance appears stuck in the <code>stopping</code> state, there might be an
   * issue with the underlying host computer. You can use the StopInstances operation
   * together with the Force parameter to force stop your instance. For more
   * information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesStopping.html">Troubleshoot
   * Amazon EC2 instance stop issues</a> in the <i>Amazon EC2 User Guide</i>.</p>
   * <p>Stopping and hibernating an instance differs from rebooting or terminating
   * it. For example, a stopped or hibernated instance retains its root volume and
   * any data volumes, unlike terminated instances where these volumes are
   * automatically deleted. For more information about the differences between
   * stopping, hibernating, rebooting, and terminating instances, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Amazon
   * EC2 instance state changes</a> in the <i>Amazon EC2 User Guide</i>.</p> <p>We
   * don't charge for instance usage or data transfer fees when an instance is
   * stopped. However, the root volume and any data volumes remain and continue to
   * persist your data, and you're charged for volume usage. Every time you start
   * your instance, Amazon EC2 charges a one-minute minimum for instance usage,
   * followed by per-second billing.</p> <p>You can't stop or hibernate instance
   * store-backed instances.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StopInstances">AWS
   * API Reference</a></p>
   */
  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 <typename StopInstancesRequestT = Model::StopInstancesRequest>
  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 <typename StopInstancesRequestT = Model::StopInstancesRequest>
  void StopInstancesAsync(const StopInstancesRequestT& request, const StopInstancesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::StopInstances, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/TerminateClientVpnConnections">AWS
   * API Reference</a></p>
   */
  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 <typename TerminateClientVpnConnectionsRequestT = Model::TerminateClientVpnConnectionsRequest>
  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 <typename TerminateClientVpnConnectionsRequestT = Model::TerminateClientVpnConnectionsRequest>
  void TerminateClientVpnConnectionsAsync(const TerminateClientVpnConnectionsRequestT& request,
                                          const TerminateClientVpnConnectionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::TerminateClientVpnConnections, request, handler, context);
  }

  /**
   * <p>Terminates (deletes) the specified instances. This operation is <a
   * href="https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html">idempotent</a>;
   * if you terminate an instance more than once, each call succeeds.</p>
   * <p> <b>Terminating an instance is permanent and irreversible.</b> </p> <p>After
   * you terminate an instance, you can no longer connect to it, and it can't be
   * recovered. All attached Amazon EBS volumes that are configured to be deleted on
   * termination are also permanently deleted and can't be recovered. All data stored
   * on instance store volumes is permanently lost. For more information, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-ec2-instance-termination-works.html">
   * How instance termination works</a>.</p> <p>Before you terminate an instance,
   * ensure that you have backed up all data that you need to retain after the
   * termination to persistent storage.</p>  <p>If you specify multiple
   * instances and the request fails (for example, because of a single incorrect
   * instance ID), none of the instances are terminated.</p> <p>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:</p> <ul> <li> <p>The specified instances that are in
   * the same Availability Zone as the protected instance are not terminated.</p>
   * </li> <li> <p>The specified instances that are in different Availability Zones,
   * where no other specified instances are protected, are successfully
   * terminated.</p> </li> </ul> <p>For example, say you have the following
   * instances:</p> <ul> <li> <p>Instance A: <code>us-east-1a</code>; Not
   * protected</p> </li> <li> <p>Instance B: <code>us-east-1a</code>; Not
   * protected</p> </li> <li> <p>Instance C: <code>us-east-1b</code>; Protected</p>
   * </li> <li> <p>Instance D: <code>us-east-1b</code>; not protected</p> </li> </ul>
   * <p>If you attempt to terminate all of these instances in the same request, the
   * request reports failure with the following results:</p> <ul> <li> <p>Instance A
   * and Instance B are successfully terminated because none of the specified
   * instances in <code>us-east-1a</code> are enabled for termination protection.</p>
   * </li> <li> <p>Instance C and Instance D fail to terminate because at least one
   * of the specified instances in <code>us-east-1b</code> (Instance C) is enabled
   * for termination protection.</p> </li> </ul> <p>Terminated instances remain
   * visible after termination (for approximately one hour).</p> <p>By default,
   * Amazon EC2 deletes all EBS volumes that were attached when the instance
   * launched. Volumes attached after instance launch continue running.</p> <p>By
   * default, the TerminateInstances operation includes a graceful operating system
   * (OS) shutdown. To bypass the graceful shutdown, use the
   * <code>skipOsShutdown</code> parameter; however, this might risk data
   * integrity.</p> <p>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 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
   * <code>DeleteOnTermination</code> block device mapping parameter set to
   * <code>true</code> are automatically deleted. For more information about the
   * differences between stopping and terminating instances, see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Amazon
   * EC2 instance state changes</a> in the <i>Amazon EC2 User Guide</i>.</p> <p>When
   * you terminate an instance, we attempt to terminate it forcibly after a short
   * while. If your instance appears stuck in the shutting-down state after a period
   * of time, there might be an issue with the underlying host computer. For more
   * information about terminating and troubleshooting terminating your instances,
   * see <a href="https://docs.aws.amazon.com/">Terminate Amazon EC2 instances</a>
   * and <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesShuttingDown.html">Troubleshooting
   * terminating your instance</a> in the <i>Amazon EC2 User Guide</i>.</p><p><h3>See
   * Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/TerminateInstances">AWS
   * API Reference</a></p>
   */
  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 <typename TerminateInstancesRequestT = Model::TerminateInstancesRequest>
  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 <typename TerminateInstancesRequestT = Model::TerminateInstancesRequest>
  void TerminateInstancesAsync(const TerminateInstancesRequestT& request, const TerminateInstancesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::TerminateInstances, request, handler, context);
  }

  /**
   * <p>Unassigns the specified IPv6 addresses or Prefix Delegation prefixes from a
   * network interface.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignIpv6Addresses">AWS
   * API Reference</a></p>
   */
  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 <typename UnassignIpv6AddressesRequestT = Model::UnassignIpv6AddressesRequest>
  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 <typename UnassignIpv6AddressesRequestT = Model::UnassignIpv6AddressesRequest>
  void UnassignIpv6AddressesAsync(const UnassignIpv6AddressesRequestT& request, const UnassignIpv6AddressesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::UnassignIpv6Addresses, request, handler, context);
  }

  /**
   * <p>Unassigns the specified secondary private IP addresses or IPv4 Prefix
   * Delegation prefixes from a network interface.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignPrivateIpAddresses">AWS
   * API Reference</a></p>
   */
  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 <typename UnassignPrivateIpAddressesRequestT = Model::UnassignPrivateIpAddressesRequest>
  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 <typename UnassignPrivateIpAddressesRequestT = Model::UnassignPrivateIpAddressesRequest>
  void UnassignPrivateIpAddressesAsync(const UnassignPrivateIpAddressesRequestT& request,
                                       const UnassignPrivateIpAddressesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::UnassignPrivateIpAddresses, request, handler, context);
  }

  /**
   * <p>Unassigns secondary private IPv4 addresses from a private NAT gateway. You
   * cannot unassign your primary private IP. For more information, see <a
   * href="https://docs.aws.amazon.com/vpc/latest/userguide/nat-gateway-working-with.html#nat-gateway-edit-secondary">Edit
   * secondary IP address associations</a> in the <i>Amazon VPC User Guide</i>.</p>
   * <p>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.</p> <p>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.</p> <p/> <p/><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignPrivateNatGatewayAddress">AWS
   * API Reference</a></p>
   */
  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 <typename UnassignPrivateNatGatewayAddressRequestT = Model::UnassignPrivateNatGatewayAddressRequest>
  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 <typename UnassignPrivateNatGatewayAddressRequestT = Model::UnassignPrivateNatGatewayAddressRequest>
  void UnassignPrivateNatGatewayAddressAsync(const UnassignPrivateNatGatewayAddressRequestT& request,
                                             const UnassignPrivateNatGatewayAddressResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::UnassignPrivateNatGatewayAddress, request, handler, context);
  }

  /**
   * <p>Unlocks a snapshot that is locked in governance mode or that is locked in
   * compliance mode but still in the cooling-off period. You can't unlock a snapshot
   * that is locked in compliance mode after the cooling-off period has
   * expired.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnlockSnapshot">AWS
   * API Reference</a></p>
   */
  virtual Model::UnlockSnapshotOutcome UnlockSnapshot(const Model::UnlockSnapshotRequest& request) const;

  /**
   * A Callable wrapper for UnlockSnapshot that returns a future to the operation so that it can be executed in parallel to other requests.
   */
  template <typename UnlockSnapshotRequestT = Model::UnlockSnapshotRequest>
  Model::UnlockSnapshotOutcomeCallable UnlockSnapshotCallable(const UnlockSnapshotRequestT& request) const {
    return SubmitCallable(&EC2Client::UnlockSnapshot, request);
  }

  /**
   * An Async wrapper for UnlockSnapshot that queues the request into a thread executor and triggers associated callback when operation has
   * finished.
   */
  template <typename UnlockSnapshotRequestT = Model::UnlockSnapshotRequest>
  void UnlockSnapshotAsync(const UnlockSnapshotRequestT& request, const UnlockSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::UnlockSnapshot, request, handler, context);
  }

  /**
   * <p>Disables detailed monitoring for a running instance. For more information,
   * see <a
   * href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch.html">Monitoring
   * your instances and volumes</a> in the <i>Amazon EC2 User
   * Guide</i>.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnmonitorInstances">AWS
   * API Reference</a></p>
   */
  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 <typename UnmonitorInstancesRequestT = Model::UnmonitorInstancesRequest>
  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 <typename UnmonitorInstancesRequestT = Model::UnmonitorInstancesRequest>
  void UnmonitorInstancesAsync(const UnmonitorInstancesRequestT& request, const UnmonitorInstancesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::UnmonitorInstances, request, handler, context);
  }

  /**
   * <p> Updates the Organizations access setting for EC2 Capacity Manager. This
   * controls whether Capacity Manager can aggregate data from all accounts in your
   * Amazon Web Services Organization or only from the current account.
   * </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateCapacityManagerOrganizationsAccess">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateCapacityManagerOrganizationsAccessOutcome UpdateCapacityManagerOrganizationsAccess(
      const Model::UpdateCapacityManagerOrganizationsAccessRequest& request) const;

  /**
   * A Callable wrapper for UpdateCapacityManagerOrganizationsAccess that returns a future to the operation so that it can be executed in
   * parallel to other requests.
   */
  template <typename UpdateCapacityManagerOrganizationsAccessRequestT = Model::UpdateCapacityManagerOrganizationsAccessRequest>
  Model::UpdateCapacityManagerOrganizationsAccessOutcomeCallable UpdateCapacityManagerOrganizationsAccessCallable(
      const UpdateCapacityManagerOrganizationsAccessRequestT& request) const {
    return SubmitCallable(&EC2Client::UpdateCapacityManagerOrganizationsAccess, request);
  }

  /**
   * An Async wrapper for UpdateCapacityManagerOrganizationsAccess that queues the request into a thread executor and triggers associated
   * callback when operation has finished.
   */
  template <typename UpdateCapacityManagerOrganizationsAccessRequestT = Model::UpdateCapacityManagerOrganizationsAccessRequest>
  void UpdateCapacityManagerOrganizationsAccessAsync(
      const UpdateCapacityManagerOrganizationsAccessRequestT& request,
      const UpdateCapacityManagerOrganizationsAccessResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::UpdateCapacityManagerOrganizationsAccess, request, handler, context);
  }

  /**
   * <p> Modifies the number of instances allocated to an interruptible reservation,
   * allowing you to add more capacity or reclaim capacity to your source Capacity
   * Reservation. </p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateInterruptibleCapacityReservationAllocation">AWS
   * API Reference</a></p>
   */
  virtual Model::UpdateInterruptibleCapacityReservationAllocationOutcome UpdateInterruptibleCapacityReservationAllocation(
      const Model::UpdateInterruptibleCapacityReservationAllocationRequest& request) const;

  /**
   * A Callable wrapper for UpdateInterruptibleCapacityReservationAllocation that returns a future to the operation so that it can be
   * executed in parallel to other requests.
   */
  template <
      typename UpdateInterruptibleCapacityReservationAllocationRequestT = Model::UpdateInterruptibleCapacityReservationAllocationRequest>
  Model::UpdateInterruptibleCapacityReservationAllocationOutcomeCallable UpdateInterruptibleCapacityReservationAllocationCallable(
      const UpdateInterruptibleCapacityReservationAllocationRequestT& request) const {
    return SubmitCallable(&EC2Client::UpdateInterruptibleCapacityReservationAllocation, request);
  }

  /**
   * An Async wrapper for UpdateInterruptibleCapacityReservationAllocation that queues the request into a thread executor and triggers
   * associated callback when operation has finished.
   */
  template <
      typename UpdateInterruptibleCapacityReservationAllocationRequestT = Model::UpdateInterruptibleCapacityReservationAllocationRequest>
  void UpdateInterruptibleCapacityReservationAllocationAsync(
      const UpdateInterruptibleCapacityReservationAllocationRequestT& request,
      const UpdateInterruptibleCapacityReservationAllocationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::UpdateInterruptibleCapacityReservationAllocation, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateSecurityGroupRuleDescriptionsEgress">AWS
   * API Reference</a></p>
   */
  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 <typename UpdateSecurityGroupRuleDescriptionsEgressRequestT = Model::UpdateSecurityGroupRuleDescriptionsEgressRequest>
  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 <typename UpdateSecurityGroupRuleDescriptionsEgressRequestT = Model::UpdateSecurityGroupRuleDescriptionsEgressRequest>
  void UpdateSecurityGroupRuleDescriptionsEgressAsync(const UpdateSecurityGroupRuleDescriptionsEgressResponseReceivedHandler& handler,
                                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                      const UpdateSecurityGroupRuleDescriptionsEgressRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::UpdateSecurityGroupRuleDescriptionsEgress, request, handler, context);
  }

  /**
   * <p>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.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateSecurityGroupRuleDescriptionsIngress">AWS
   * API Reference</a></p>
   */
  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 <typename UpdateSecurityGroupRuleDescriptionsIngressRequestT = Model::UpdateSecurityGroupRuleDescriptionsIngressRequest>
  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 <typename UpdateSecurityGroupRuleDescriptionsIngressRequestT = Model::UpdateSecurityGroupRuleDescriptionsIngressRequest>
  void UpdateSecurityGroupRuleDescriptionsIngressAsync(const UpdateSecurityGroupRuleDescriptionsIngressResponseReceivedHandler& handler,
                                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                       const UpdateSecurityGroupRuleDescriptionsIngressRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::UpdateSecurityGroupRuleDescriptionsIngress, request, handler, context);
  }

  /**
   * <p>Stops advertising an address range that is provisioned as an address
   * pool.</p> <p>You can perform this operation at most once every 10 seconds, even
   * if you specify different address ranges each time.</p> <p>It can take a few
   * minutes before traffic to the specified addresses stops routing to Amazon Web
   * Services because of BGP propagation delays.</p><p><h3>See Also:</h3>   <a
   * href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/WithdrawByoipCidr">AWS
   * API Reference</a></p>
   */
  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 <typename WithdrawByoipCidrRequestT = Model::WithdrawByoipCidrRequest>
  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 <typename WithdrawByoipCidrRequestT = Model::WithdrawByoipCidrRequest>
  void WithdrawByoipCidrAsync(const WithdrawByoipCidrRequestT& request, const WithdrawByoipCidrResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::WithdrawByoipCidr, request, handler, context);
  }

  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<EC2EndpointProviderBase>& accessEndpointProvider();

 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<EC2Client>;
  void init(const EC2ClientConfiguration& clientConfiguration);

  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, EC2Error> InvokeOperationOutcome;

  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;

  EC2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<EC2EndpointProviderBase> m_endpointProvider;
};

}  // namespace EC2
}  // namespace Aws
