EC2Client.h

 
#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 {
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;
 
  EC2Client(const Aws::EC2::EC2ClientConfiguration& clientConfiguration = Aws::EC2::EC2ClientConfiguration(),
            std::shared_ptr<EC2EndpointProviderBase> endpointProvider = nullptr);
 
  EC2Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<EC2EndpointProviderBase> endpointProvider = nullptr,
            const Aws::EC2::EC2ClientConfiguration& clientConfiguration = Aws::EC2::EC2ClientConfiguration());
 
  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 */
  EC2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EC2Client(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EC2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~EC2Client();
 
  virtual Model::AcceptAddressTransferOutcome AcceptAddressTransfer(const Model::AcceptAddressTransferRequest& request) const;
 
  template <typename AcceptAddressTransferRequestT = Model::AcceptAddressTransferRequest>
  Model::AcceptAddressTransferOutcomeCallable AcceptAddressTransferCallable(const AcceptAddressTransferRequestT& request) const {
    return SubmitCallable(&EC2Client::AcceptAddressTransfer, request);
  }
 
  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);
  }
 
  virtual Model::AcceptCapacityReservationBillingOwnershipOutcome AcceptCapacityReservationBillingOwnership(
      const Model::AcceptCapacityReservationBillingOwnershipRequest& request) const;
 
  template <typename AcceptCapacityReservationBillingOwnershipRequestT = Model::AcceptCapacityReservationBillingOwnershipRequest>
  Model::AcceptCapacityReservationBillingOwnershipOutcomeCallable AcceptCapacityReservationBillingOwnershipCallable(
      const AcceptCapacityReservationBillingOwnershipRequestT& request) const {
    return SubmitCallable(&EC2Client::AcceptCapacityReservationBillingOwnership, request);
  }
 
  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);
  }
 
  virtual Model::AcceptReservedInstancesExchangeQuoteOutcome AcceptReservedInstancesExchangeQuote(
      const Model::AcceptReservedInstancesExchangeQuoteRequest& request) const;
 
  template <typename AcceptReservedInstancesExchangeQuoteRequestT = Model::AcceptReservedInstancesExchangeQuoteRequest>
  Model::AcceptReservedInstancesExchangeQuoteOutcomeCallable AcceptReservedInstancesExchangeQuoteCallable(
      const AcceptReservedInstancesExchangeQuoteRequestT& request) const {
    return SubmitCallable(&EC2Client::AcceptReservedInstancesExchangeQuote, request);
  }
 
  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);
  }
 
  virtual Model::AcceptTransitGatewayClientVpnAttachmentOutcome AcceptTransitGatewayClientVpnAttachment(
      const Model::AcceptTransitGatewayClientVpnAttachmentRequest& request) const;
 
  template <typename AcceptTransitGatewayClientVpnAttachmentRequestT = Model::AcceptTransitGatewayClientVpnAttachmentRequest>
  Model::AcceptTransitGatewayClientVpnAttachmentOutcomeCallable AcceptTransitGatewayClientVpnAttachmentCallable(
      const AcceptTransitGatewayClientVpnAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::AcceptTransitGatewayClientVpnAttachment, request);
  }
 
  template <typename AcceptTransitGatewayClientVpnAttachmentRequestT = Model::AcceptTransitGatewayClientVpnAttachmentRequest>
  void AcceptTransitGatewayClientVpnAttachmentAsync(const AcceptTransitGatewayClientVpnAttachmentRequestT& request,
                                                    const AcceptTransitGatewayClientVpnAttachmentResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AcceptTransitGatewayClientVpnAttachment, request, handler, context);
  }
 
  virtual Model::AcceptTransitGatewayMulticastDomainAssociationsOutcome AcceptTransitGatewayMulticastDomainAssociations(
      const Model::AcceptTransitGatewayMulticastDomainAssociationsRequest& request = {}) const;
 
  template <
      typename AcceptTransitGatewayMulticastDomainAssociationsRequestT = Model::AcceptTransitGatewayMulticastDomainAssociationsRequest>
  Model::AcceptTransitGatewayMulticastDomainAssociationsOutcomeCallable AcceptTransitGatewayMulticastDomainAssociationsCallable(
      const AcceptTransitGatewayMulticastDomainAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::AcceptTransitGatewayMulticastDomainAssociations, request);
  }
 
  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);
  }
 
  virtual Model::AcceptTransitGatewayPeeringAttachmentOutcome AcceptTransitGatewayPeeringAttachment(
      const Model::AcceptTransitGatewayPeeringAttachmentRequest& request) const;
 
  template <typename AcceptTransitGatewayPeeringAttachmentRequestT = Model::AcceptTransitGatewayPeeringAttachmentRequest>
  Model::AcceptTransitGatewayPeeringAttachmentOutcomeCallable AcceptTransitGatewayPeeringAttachmentCallable(
      const AcceptTransitGatewayPeeringAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::AcceptTransitGatewayPeeringAttachment, request);
  }
 
  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);
  }
 
  virtual Model::AcceptTransitGatewayVpcAttachmentOutcome AcceptTransitGatewayVpcAttachment(
      const Model::AcceptTransitGatewayVpcAttachmentRequest& request) const;
 
  template <typename AcceptTransitGatewayVpcAttachmentRequestT = Model::AcceptTransitGatewayVpcAttachmentRequest>
  Model::AcceptTransitGatewayVpcAttachmentOutcomeCallable AcceptTransitGatewayVpcAttachmentCallable(
      const AcceptTransitGatewayVpcAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::AcceptTransitGatewayVpcAttachment, request);
  }
 
  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);
  }
 
  virtual Model::AcceptVpcEndpointConnectionsOutcome AcceptVpcEndpointConnections(
      const Model::AcceptVpcEndpointConnectionsRequest& request) const;
 
  template <typename AcceptVpcEndpointConnectionsRequestT = Model::AcceptVpcEndpointConnectionsRequest>
  Model::AcceptVpcEndpointConnectionsOutcomeCallable AcceptVpcEndpointConnectionsCallable(
      const AcceptVpcEndpointConnectionsRequestT& request) const {
    return SubmitCallable(&EC2Client::AcceptVpcEndpointConnections, request);
  }
 
  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);
  }
 
  virtual Model::AcceptVpcPeeringConnectionOutcome AcceptVpcPeeringConnection(
      const Model::AcceptVpcPeeringConnectionRequest& request) const;
 
  template <typename AcceptVpcPeeringConnectionRequestT = Model::AcceptVpcPeeringConnectionRequest>
  Model::AcceptVpcPeeringConnectionOutcomeCallable AcceptVpcPeeringConnectionCallable(
      const AcceptVpcPeeringConnectionRequestT& request) const {
    return SubmitCallable(&EC2Client::AcceptVpcPeeringConnection, request);
  }
 
  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);
  }
 
  virtual Model::AdvertiseByoipCidrOutcome AdvertiseByoipCidr(const Model::AdvertiseByoipCidrRequest& request) const;
 
  template <typename AdvertiseByoipCidrRequestT = Model::AdvertiseByoipCidrRequest>
  Model::AdvertiseByoipCidrOutcomeCallable AdvertiseByoipCidrCallable(const AdvertiseByoipCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::AdvertiseByoipCidr, request);
  }
 
  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);
  }
 
  virtual Model::AllocateAddressOutcome AllocateAddress(const Model::AllocateAddressRequest& request = {}) const;
 
  template <typename AllocateAddressRequestT = Model::AllocateAddressRequest>
  Model::AllocateAddressOutcomeCallable AllocateAddressCallable(const AllocateAddressRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::AllocateAddress, request);
  }
 
  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);
  }
 
  virtual Model::AllocateHostsOutcome AllocateHosts(const Model::AllocateHostsRequest& request = {}) const;
 
  template <typename AllocateHostsRequestT = Model::AllocateHostsRequest>
  Model::AllocateHostsOutcomeCallable AllocateHostsCallable(const AllocateHostsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::AllocateHosts, request);
  }
 
  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);
  }
 
  virtual Model::AllocateIpamPoolCidrOutcome AllocateIpamPoolCidr(const Model::AllocateIpamPoolCidrRequest& request) const;
 
  template <typename AllocateIpamPoolCidrRequestT = Model::AllocateIpamPoolCidrRequest>
  Model::AllocateIpamPoolCidrOutcomeCallable AllocateIpamPoolCidrCallable(const AllocateIpamPoolCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::AllocateIpamPoolCidr, request);
  }
 
  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);
  }
 
  virtual Model::ApplySecurityGroupsToClientVpnTargetNetworkOutcome ApplySecurityGroupsToClientVpnTargetNetwork(
      const Model::ApplySecurityGroupsToClientVpnTargetNetworkRequest& request) const;
 
  template <typename ApplySecurityGroupsToClientVpnTargetNetworkRequestT = Model::ApplySecurityGroupsToClientVpnTargetNetworkRequest>
  Model::ApplySecurityGroupsToClientVpnTargetNetworkOutcomeCallable ApplySecurityGroupsToClientVpnTargetNetworkCallable(
      const ApplySecurityGroupsToClientVpnTargetNetworkRequestT& request) const {
    return SubmitCallable(&EC2Client::ApplySecurityGroupsToClientVpnTargetNetwork, request);
  }
 
  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);
  }
 
  virtual Model::AssignIpv6AddressesOutcome AssignIpv6Addresses(const Model::AssignIpv6AddressesRequest& request) const;
 
  template <typename AssignIpv6AddressesRequestT = Model::AssignIpv6AddressesRequest>
  Model::AssignIpv6AddressesOutcomeCallable AssignIpv6AddressesCallable(const AssignIpv6AddressesRequestT& request) const {
    return SubmitCallable(&EC2Client::AssignIpv6Addresses, request);
  }
 
  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);
  }
 
  virtual Model::AssignPrivateIpAddressesOutcome AssignPrivateIpAddresses(const Model::AssignPrivateIpAddressesRequest& request) const;
 
  template <typename AssignPrivateIpAddressesRequestT = Model::AssignPrivateIpAddressesRequest>
  Model::AssignPrivateIpAddressesOutcomeCallable AssignPrivateIpAddressesCallable(const AssignPrivateIpAddressesRequestT& request) const {
    return SubmitCallable(&EC2Client::AssignPrivateIpAddresses, request);
  }
 
  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);
  }
 
  virtual Model::AssignPrivateNatGatewayAddressOutcome AssignPrivateNatGatewayAddress(
      const Model::AssignPrivateNatGatewayAddressRequest& request) const;
 
  template <typename AssignPrivateNatGatewayAddressRequestT = Model::AssignPrivateNatGatewayAddressRequest>
  Model::AssignPrivateNatGatewayAddressOutcomeCallable AssignPrivateNatGatewayAddressCallable(
      const AssignPrivateNatGatewayAddressRequestT& request) const {
    return SubmitCallable(&EC2Client::AssignPrivateNatGatewayAddress, request);
  }
 
  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);
  }
 
  virtual Model::AssociateAddressOutcome AssociateAddress(const Model::AssociateAddressRequest& request = {}) const;
 
  template <typename AssociateAddressRequestT = Model::AssociateAddressRequest>
  Model::AssociateAddressOutcomeCallable AssociateAddressCallable(const AssociateAddressRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::AssociateAddress, request);
  }
 
  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);
  }
 
  virtual Model::AssociateCapacityReservationBillingOwnerOutcome AssociateCapacityReservationBillingOwner(
      const Model::AssociateCapacityReservationBillingOwnerRequest& request) const;
 
  template <typename AssociateCapacityReservationBillingOwnerRequestT = Model::AssociateCapacityReservationBillingOwnerRequest>
  Model::AssociateCapacityReservationBillingOwnerOutcomeCallable AssociateCapacityReservationBillingOwnerCallable(
      const AssociateCapacityReservationBillingOwnerRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateCapacityReservationBillingOwner, request);
  }
 
  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);
  }
 
  virtual Model::AssociateClientVpnTargetNetworkOutcome AssociateClientVpnTargetNetwork(
      const Model::AssociateClientVpnTargetNetworkRequest& request) const;
 
  template <typename AssociateClientVpnTargetNetworkRequestT = Model::AssociateClientVpnTargetNetworkRequest>
  Model::AssociateClientVpnTargetNetworkOutcomeCallable AssociateClientVpnTargetNetworkCallable(
      const AssociateClientVpnTargetNetworkRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateClientVpnTargetNetwork, request);
  }
 
  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);
  }
 
  virtual Model::AssociateDhcpOptionsOutcome AssociateDhcpOptions(const Model::AssociateDhcpOptionsRequest& request) const;
 
  template <typename AssociateDhcpOptionsRequestT = Model::AssociateDhcpOptionsRequest>
  Model::AssociateDhcpOptionsOutcomeCallable AssociateDhcpOptionsCallable(const AssociateDhcpOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateDhcpOptions, request);
  }
 
  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);
  }
 
  virtual Model::AssociateEnclaveCertificateIamRoleOutcome AssociateEnclaveCertificateIamRole(
      const Model::AssociateEnclaveCertificateIamRoleRequest& request) const;
 
  template <typename AssociateEnclaveCertificateIamRoleRequestT = Model::AssociateEnclaveCertificateIamRoleRequest>
  Model::AssociateEnclaveCertificateIamRoleOutcomeCallable AssociateEnclaveCertificateIamRoleCallable(
      const AssociateEnclaveCertificateIamRoleRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateEnclaveCertificateIamRole, request);
  }
 
  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);
  }
 
  virtual Model::AssociateIamInstanceProfileOutcome AssociateIamInstanceProfile(
      const Model::AssociateIamInstanceProfileRequest& request) const;
 
  template <typename AssociateIamInstanceProfileRequestT = Model::AssociateIamInstanceProfileRequest>
  Model::AssociateIamInstanceProfileOutcomeCallable AssociateIamInstanceProfileCallable(
      const AssociateIamInstanceProfileRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateIamInstanceProfile, request);
  }
 
  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);
  }
 
  virtual Model::AssociateInstanceEventWindowOutcome AssociateInstanceEventWindow(
      const Model::AssociateInstanceEventWindowRequest& request) const;
 
  template <typename AssociateInstanceEventWindowRequestT = Model::AssociateInstanceEventWindowRequest>
  Model::AssociateInstanceEventWindowOutcomeCallable AssociateInstanceEventWindowCallable(
      const AssociateInstanceEventWindowRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateInstanceEventWindow, request);
  }
 
  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);
  }
 
  virtual Model::AssociateIpamByoasnOutcome AssociateIpamByoasn(const Model::AssociateIpamByoasnRequest& request) const;
 
  template <typename AssociateIpamByoasnRequestT = Model::AssociateIpamByoasnRequest>
  Model::AssociateIpamByoasnOutcomeCallable AssociateIpamByoasnCallable(const AssociateIpamByoasnRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateIpamByoasn, request);
  }
 
  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);
  }
 
  virtual Model::AssociateIpamResourceDiscoveryOutcome AssociateIpamResourceDiscovery(
      const Model::AssociateIpamResourceDiscoveryRequest& request) const;
 
  template <typename AssociateIpamResourceDiscoveryRequestT = Model::AssociateIpamResourceDiscoveryRequest>
  Model::AssociateIpamResourceDiscoveryOutcomeCallable AssociateIpamResourceDiscoveryCallable(
      const AssociateIpamResourceDiscoveryRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateIpamResourceDiscovery, request);
  }
 
  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);
  }
 
  virtual Model::AssociateNatGatewayAddressOutcome AssociateNatGatewayAddress(
      const Model::AssociateNatGatewayAddressRequest& request) const;
 
  template <typename AssociateNatGatewayAddressRequestT = Model::AssociateNatGatewayAddressRequest>
  Model::AssociateNatGatewayAddressOutcomeCallable AssociateNatGatewayAddressCallable(
      const AssociateNatGatewayAddressRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateNatGatewayAddress, request);
  }
 
  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);
  }
 
  virtual Model::AssociateRouteServerOutcome AssociateRouteServer(const Model::AssociateRouteServerRequest& request) const;
 
  template <typename AssociateRouteServerRequestT = Model::AssociateRouteServerRequest>
  Model::AssociateRouteServerOutcomeCallable AssociateRouteServerCallable(const AssociateRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateRouteServer, request);
  }
 
  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);
  }
 
  virtual Model::AssociateRouteTableOutcome AssociateRouteTable(const Model::AssociateRouteTableRequest& request) const;
 
  template <typename AssociateRouteTableRequestT = Model::AssociateRouteTableRequest>
  Model::AssociateRouteTableOutcomeCallable AssociateRouteTableCallable(const AssociateRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::AssociateSecurityGroupVpcOutcome AssociateSecurityGroupVpc(const Model::AssociateSecurityGroupVpcRequest& request) const;
 
  template <typename AssociateSecurityGroupVpcRequestT = Model::AssociateSecurityGroupVpcRequest>
  Model::AssociateSecurityGroupVpcOutcomeCallable AssociateSecurityGroupVpcCallable(
      const AssociateSecurityGroupVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateSecurityGroupVpc, request);
  }
 
  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);
  }
 
  virtual Model::AssociateSubnetCidrBlockOutcome AssociateSubnetCidrBlock(const Model::AssociateSubnetCidrBlockRequest& request) const;
 
  template <typename AssociateSubnetCidrBlockRequestT = Model::AssociateSubnetCidrBlockRequest>
  Model::AssociateSubnetCidrBlockOutcomeCallable AssociateSubnetCidrBlockCallable(const AssociateSubnetCidrBlockRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateSubnetCidrBlock, request);
  }
 
  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);
  }
 
  virtual Model::AssociateTransitGatewayMulticastDomainOutcome AssociateTransitGatewayMulticastDomain(
      const Model::AssociateTransitGatewayMulticastDomainRequest& request) const;
 
  template <typename AssociateTransitGatewayMulticastDomainRequestT = Model::AssociateTransitGatewayMulticastDomainRequest>
  Model::AssociateTransitGatewayMulticastDomainOutcomeCallable AssociateTransitGatewayMulticastDomainCallable(
      const AssociateTransitGatewayMulticastDomainRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateTransitGatewayMulticastDomain, request);
  }
 
  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);
  }
 
  virtual Model::AssociateTransitGatewayPolicyTableOutcome AssociateTransitGatewayPolicyTable(
      const Model::AssociateTransitGatewayPolicyTableRequest& request) const;
 
  template <typename AssociateTransitGatewayPolicyTableRequestT = Model::AssociateTransitGatewayPolicyTableRequest>
  Model::AssociateTransitGatewayPolicyTableOutcomeCallable AssociateTransitGatewayPolicyTableCallable(
      const AssociateTransitGatewayPolicyTableRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateTransitGatewayPolicyTable, request);
  }
 
  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);
  }
 
  virtual Model::AssociateTransitGatewayRouteTableOutcome AssociateTransitGatewayRouteTable(
      const Model::AssociateTransitGatewayRouteTableRequest& request) const;
 
  template <typename AssociateTransitGatewayRouteTableRequestT = Model::AssociateTransitGatewayRouteTableRequest>
  Model::AssociateTransitGatewayRouteTableOutcomeCallable AssociateTransitGatewayRouteTableCallable(
      const AssociateTransitGatewayRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateTransitGatewayRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::AssociateTrunkInterfaceOutcome AssociateTrunkInterface(const Model::AssociateTrunkInterfaceRequest& request) const;
 
  template <typename AssociateTrunkInterfaceRequestT = Model::AssociateTrunkInterfaceRequest>
  Model::AssociateTrunkInterfaceOutcomeCallable AssociateTrunkInterfaceCallable(const AssociateTrunkInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateTrunkInterface, request);
  }
 
  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);
  }
 
  virtual Model::AssociateVpcCidrBlockOutcome AssociateVpcCidrBlock(const Model::AssociateVpcCidrBlockRequest& request) const;
 
  template <typename AssociateVpcCidrBlockRequestT = Model::AssociateVpcCidrBlockRequest>
  Model::AssociateVpcCidrBlockOutcomeCallable AssociateVpcCidrBlockCallable(const AssociateVpcCidrBlockRequestT& request) const {
    return SubmitCallable(&EC2Client::AssociateVpcCidrBlock, request);
  }
 
  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);
  }
 
  virtual Model::AttachClassicLinkVpcOutcome AttachClassicLinkVpc(const Model::AttachClassicLinkVpcRequest& request) const;
 
  template <typename AttachClassicLinkVpcRequestT = Model::AttachClassicLinkVpcRequest>
  Model::AttachClassicLinkVpcOutcomeCallable AttachClassicLinkVpcCallable(const AttachClassicLinkVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::AttachClassicLinkVpc, request);
  }
 
  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);
  }
 
  virtual Model::AttachImageWatermarkOutcome AttachImageWatermark(const Model::AttachImageWatermarkRequest& request) const;
 
  template <typename AttachImageWatermarkRequestT = Model::AttachImageWatermarkRequest>
  Model::AttachImageWatermarkOutcomeCallable AttachImageWatermarkCallable(const AttachImageWatermarkRequestT& request) const {
    return SubmitCallable(&EC2Client::AttachImageWatermark, request);
  }
 
  template <typename AttachImageWatermarkRequestT = Model::AttachImageWatermarkRequest>
  void AttachImageWatermarkAsync(const AttachImageWatermarkRequestT& request, const AttachImageWatermarkResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::AttachImageWatermark, request, handler, context);
  }
 
  virtual Model::AttachInternetGatewayOutcome AttachInternetGateway(const Model::AttachInternetGatewayRequest& request) const;
 
  template <typename AttachInternetGatewayRequestT = Model::AttachInternetGatewayRequest>
  Model::AttachInternetGatewayOutcomeCallable AttachInternetGatewayCallable(const AttachInternetGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::AttachInternetGateway, request);
  }
 
  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);
  }
 
  virtual Model::AttachNetworkInterfaceOutcome AttachNetworkInterface(const Model::AttachNetworkInterfaceRequest& request) const;
 
  template <typename AttachNetworkInterfaceRequestT = Model::AttachNetworkInterfaceRequest>
  Model::AttachNetworkInterfaceOutcomeCallable AttachNetworkInterfaceCallable(const AttachNetworkInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::AttachNetworkInterface, request);
  }
 
  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);
  }
 
  virtual Model::AttachVerifiedAccessTrustProviderOutcome AttachVerifiedAccessTrustProvider(
      const Model::AttachVerifiedAccessTrustProviderRequest& request) const;
 
  template <typename AttachVerifiedAccessTrustProviderRequestT = Model::AttachVerifiedAccessTrustProviderRequest>
  Model::AttachVerifiedAccessTrustProviderOutcomeCallable AttachVerifiedAccessTrustProviderCallable(
      const AttachVerifiedAccessTrustProviderRequestT& request) const {
    return SubmitCallable(&EC2Client::AttachVerifiedAccessTrustProvider, request);
  }
 
  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);
  }
 
  virtual Model::AttachVolumeOutcome AttachVolume(const Model::AttachVolumeRequest& request) const;
 
  template <typename AttachVolumeRequestT = Model::AttachVolumeRequest>
  Model::AttachVolumeOutcomeCallable AttachVolumeCallable(const AttachVolumeRequestT& request) const {
    return SubmitCallable(&EC2Client::AttachVolume, request);
  }
 
  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);
  }
 
  virtual Model::AttachVpnGatewayOutcome AttachVpnGateway(const Model::AttachVpnGatewayRequest& request) const;
 
  template <typename AttachVpnGatewayRequestT = Model::AttachVpnGatewayRequest>
  Model::AttachVpnGatewayOutcomeCallable AttachVpnGatewayCallable(const AttachVpnGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::AttachVpnGateway, request);
  }
 
  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);
  }
 
  virtual Model::AuthorizeClientVpnIngressOutcome AuthorizeClientVpnIngress(const Model::AuthorizeClientVpnIngressRequest& request) const;
 
  template <typename AuthorizeClientVpnIngressRequestT = Model::AuthorizeClientVpnIngressRequest>
  Model::AuthorizeClientVpnIngressOutcomeCallable AuthorizeClientVpnIngressCallable(
      const AuthorizeClientVpnIngressRequestT& request) const {
    return SubmitCallable(&EC2Client::AuthorizeClientVpnIngress, request);
  }
 
  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);
  }
 
  virtual Model::AuthorizeSecurityGroupEgressOutcome AuthorizeSecurityGroupEgress(
      const Model::AuthorizeSecurityGroupEgressRequest& request) const;
 
  template <typename AuthorizeSecurityGroupEgressRequestT = Model::AuthorizeSecurityGroupEgressRequest>
  Model::AuthorizeSecurityGroupEgressOutcomeCallable AuthorizeSecurityGroupEgressCallable(
      const AuthorizeSecurityGroupEgressRequestT& request) const {
    return SubmitCallable(&EC2Client::AuthorizeSecurityGroupEgress, request);
  }
 
  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);
  }
 
  virtual Model::AuthorizeSecurityGroupIngressOutcome AuthorizeSecurityGroupIngress(
      const Model::AuthorizeSecurityGroupIngressRequest& request = {}) const;
 
  template <typename AuthorizeSecurityGroupIngressRequestT = Model::AuthorizeSecurityGroupIngressRequest>
  Model::AuthorizeSecurityGroupIngressOutcomeCallable AuthorizeSecurityGroupIngressCallable(
      const AuthorizeSecurityGroupIngressRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::AuthorizeSecurityGroupIngress, request);
  }
 
  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);
  }
 
  virtual Model::BundleInstanceOutcome BundleInstance(const Model::BundleInstanceRequest& request) const;
 
  template <typename BundleInstanceRequestT = Model::BundleInstanceRequest>
  Model::BundleInstanceOutcomeCallable BundleInstanceCallable(const BundleInstanceRequestT& request) const {
    return SubmitCallable(&EC2Client::BundleInstance, request);
  }
 
  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);
  }
 
  virtual Model::CancelBundleTaskOutcome CancelBundleTask(const Model::CancelBundleTaskRequest& request) const;
 
  template <typename CancelBundleTaskRequestT = Model::CancelBundleTaskRequest>
  Model::CancelBundleTaskOutcomeCallable CancelBundleTaskCallable(const CancelBundleTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelBundleTask, request);
  }
 
  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);
  }
 
  virtual Model::CancelCapacityReservationOutcome CancelCapacityReservation(const Model::CancelCapacityReservationRequest& request) const;
 
  template <typename CancelCapacityReservationRequestT = Model::CancelCapacityReservationRequest>
  Model::CancelCapacityReservationOutcomeCallable CancelCapacityReservationCallable(
      const CancelCapacityReservationRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelCapacityReservation, request);
  }
 
  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);
  }
 
  virtual Model::CancelCapacityReservationFleetsOutcome CancelCapacityReservationFleets(
      const Model::CancelCapacityReservationFleetsRequest& request) const;
 
  template <typename CancelCapacityReservationFleetsRequestT = Model::CancelCapacityReservationFleetsRequest>
  Model::CancelCapacityReservationFleetsOutcomeCallable CancelCapacityReservationFleetsCallable(
      const CancelCapacityReservationFleetsRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelCapacityReservationFleets, request);
  }
 
  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);
  }
 
  virtual Model::CancelConversionTaskOutcome CancelConversionTask(const Model::CancelConversionTaskRequest& request) const;
 
  template <typename CancelConversionTaskRequestT = Model::CancelConversionTaskRequest>
  Model::CancelConversionTaskOutcomeCallable CancelConversionTaskCallable(const CancelConversionTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelConversionTask, request);
  }
 
  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);
  }
 
  virtual Model::CancelDeclarativePoliciesReportOutcome CancelDeclarativePoliciesReport(
      const Model::CancelDeclarativePoliciesReportRequest& request) const;
 
  template <typename CancelDeclarativePoliciesReportRequestT = Model::CancelDeclarativePoliciesReportRequest>
  Model::CancelDeclarativePoliciesReportOutcomeCallable CancelDeclarativePoliciesReportCallable(
      const CancelDeclarativePoliciesReportRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelDeclarativePoliciesReport, request);
  }
 
  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);
  }
 
  virtual Model::CancelExportTaskOutcome CancelExportTask(const Model::CancelExportTaskRequest& request) const;
 
  template <typename CancelExportTaskRequestT = Model::CancelExportTaskRequest>
  Model::CancelExportTaskOutcomeCallable CancelExportTaskCallable(const CancelExportTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelExportTask, request);
  }
 
  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);
  }
 
  virtual Model::CancelImageLaunchPermissionOutcome CancelImageLaunchPermission(
      const Model::CancelImageLaunchPermissionRequest& request) const;
 
  template <typename CancelImageLaunchPermissionRequestT = Model::CancelImageLaunchPermissionRequest>
  Model::CancelImageLaunchPermissionOutcomeCallable CancelImageLaunchPermissionCallable(
      const CancelImageLaunchPermissionRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelImageLaunchPermission, request);
  }
 
  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);
  }
 
  virtual Model::CancelImportTaskOutcome CancelImportTask(const Model::CancelImportTaskRequest& request = {}) const;
 
  template <typename CancelImportTaskRequestT = Model::CancelImportTaskRequest>
  Model::CancelImportTaskOutcomeCallable CancelImportTaskCallable(const CancelImportTaskRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CancelImportTask, request);
  }
 
  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);
  }
 
  virtual Model::CancelReservedInstancesListingOutcome CancelReservedInstancesListing(
      const Model::CancelReservedInstancesListingRequest& request) const;
 
  template <typename CancelReservedInstancesListingRequestT = Model::CancelReservedInstancesListingRequest>
  Model::CancelReservedInstancesListingOutcomeCallable CancelReservedInstancesListingCallable(
      const CancelReservedInstancesListingRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelReservedInstancesListing, request);
  }
 
  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);
  }
 
  virtual Model::CancelSpotFleetRequestsOutcome CancelSpotFleetRequests(const Model::CancelSpotFleetRequestsRequest& request) const;
 
  template <typename CancelSpotFleetRequestsRequestT = Model::CancelSpotFleetRequestsRequest>
  Model::CancelSpotFleetRequestsOutcomeCallable CancelSpotFleetRequestsCallable(const CancelSpotFleetRequestsRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelSpotFleetRequests, request);
  }
 
  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);
  }
 
  virtual Model::CancelSpotInstanceRequestsOutcome CancelSpotInstanceRequests(
      const Model::CancelSpotInstanceRequestsRequest& request) const;
 
  template <typename CancelSpotInstanceRequestsRequestT = Model::CancelSpotInstanceRequestsRequest>
  Model::CancelSpotInstanceRequestsOutcomeCallable CancelSpotInstanceRequestsCallable(
      const CancelSpotInstanceRequestsRequestT& request) const {
    return SubmitCallable(&EC2Client::CancelSpotInstanceRequests, request);
  }
 
  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);
  }
 
  virtual Model::ConfirmProductInstanceOutcome ConfirmProductInstance(const Model::ConfirmProductInstanceRequest& request) const;
 
  template <typename ConfirmProductInstanceRequestT = Model::ConfirmProductInstanceRequest>
  Model::ConfirmProductInstanceOutcomeCallable ConfirmProductInstanceCallable(const ConfirmProductInstanceRequestT& request) const {
    return SubmitCallable(&EC2Client::ConfirmProductInstance, request);
  }
 
  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);
  }
 
  virtual Model::CopyFpgaImageOutcome CopyFpgaImage(const Model::CopyFpgaImageRequest& request) const;
 
  template <typename CopyFpgaImageRequestT = Model::CopyFpgaImageRequest>
  Model::CopyFpgaImageOutcomeCallable CopyFpgaImageCallable(const CopyFpgaImageRequestT& request) const {
    return SubmitCallable(&EC2Client::CopyFpgaImage, request);
  }
 
  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);
  }
 
  virtual Model::CopyImageOutcome CopyImage(const Model::CopyImageRequest& request) const;
 
  template <typename CopyImageRequestT = Model::CopyImageRequest>
  Model::CopyImageOutcomeCallable CopyImageCallable(const CopyImageRequestT& request) const {
    return SubmitCallable(&EC2Client::CopyImage, request);
  }
 
  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);
  }
 
  virtual Model::CopySnapshotOutcome CopySnapshot(const Model::CopySnapshotRequest& request) const;
 
  template <typename CopySnapshotRequestT = Model::CopySnapshotRequest>
  Model::CopySnapshotOutcomeCallable CopySnapshotCallable(const CopySnapshotRequestT& request) const {
    return SubmitCallable(&EC2Client::CopySnapshot, request);
  }
 
  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);
  }
 
  virtual Model::CopyVolumesOutcome CopyVolumes(const Model::CopyVolumesRequest& request) const;
 
  template <typename CopyVolumesRequestT = Model::CopyVolumesRequest>
  Model::CopyVolumesOutcomeCallable CopyVolumesCallable(const CopyVolumesRequestT& request) const {
    return SubmitCallable(&EC2Client::CopyVolumes, request);
  }
 
  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);
  }
 
  virtual Model::CreateCapacityManagerDataExportOutcome CreateCapacityManagerDataExport(
      const Model::CreateCapacityManagerDataExportRequest& request) const;
 
  template <typename CreateCapacityManagerDataExportRequestT = Model::CreateCapacityManagerDataExportRequest>
  Model::CreateCapacityManagerDataExportOutcomeCallable CreateCapacityManagerDataExportCallable(
      const CreateCapacityManagerDataExportRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCapacityManagerDataExport, request);
  }
 
  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);
  }
 
  virtual Model::CreateCapacityReservationOutcome CreateCapacityReservation(const Model::CreateCapacityReservationRequest& request) const;
 
  template <typename CreateCapacityReservationRequestT = Model::CreateCapacityReservationRequest>
  Model::CreateCapacityReservationOutcomeCallable CreateCapacityReservationCallable(
      const CreateCapacityReservationRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCapacityReservation, request);
  }
 
  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);
  }
 
  virtual Model::CreateCapacityReservationBySplittingOutcome CreateCapacityReservationBySplitting(
      const Model::CreateCapacityReservationBySplittingRequest& request) const;
 
  template <typename CreateCapacityReservationBySplittingRequestT = Model::CreateCapacityReservationBySplittingRequest>
  Model::CreateCapacityReservationBySplittingOutcomeCallable CreateCapacityReservationBySplittingCallable(
      const CreateCapacityReservationBySplittingRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCapacityReservationBySplitting, request);
  }
 
  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);
  }
 
  virtual Model::CreateCapacityReservationCancellationQuoteOutcome CreateCapacityReservationCancellationQuote(
      const Model::CreateCapacityReservationCancellationQuoteRequest& request) const;
 
  template <typename CreateCapacityReservationCancellationQuoteRequestT = Model::CreateCapacityReservationCancellationQuoteRequest>
  Model::CreateCapacityReservationCancellationQuoteOutcomeCallable CreateCapacityReservationCancellationQuoteCallable(
      const CreateCapacityReservationCancellationQuoteRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCapacityReservationCancellationQuote, request);
  }
 
  template <typename CreateCapacityReservationCancellationQuoteRequestT = Model::CreateCapacityReservationCancellationQuoteRequest>
  void CreateCapacityReservationCancellationQuoteAsync(
      const CreateCapacityReservationCancellationQuoteRequestT& request,
      const CreateCapacityReservationCancellationQuoteResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::CreateCapacityReservationCancellationQuote, request, handler, context);
  }
 
  virtual Model::CreateCapacityReservationFleetOutcome CreateCapacityReservationFleet(
      const Model::CreateCapacityReservationFleetRequest& request) const;
 
  template <typename CreateCapacityReservationFleetRequestT = Model::CreateCapacityReservationFleetRequest>
  Model::CreateCapacityReservationFleetOutcomeCallable CreateCapacityReservationFleetCallable(
      const CreateCapacityReservationFleetRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCapacityReservationFleet, request);
  }
 
  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);
  }
 
  virtual Model::CreateCarrierGatewayOutcome CreateCarrierGateway(const Model::CreateCarrierGatewayRequest& request) const;
 
  template <typename CreateCarrierGatewayRequestT = Model::CreateCarrierGatewayRequest>
  Model::CreateCarrierGatewayOutcomeCallable CreateCarrierGatewayCallable(const CreateCarrierGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCarrierGateway, request);
  }
 
  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);
  }
 
  virtual Model::CreateClientVpnEndpointOutcome CreateClientVpnEndpoint(const Model::CreateClientVpnEndpointRequest& request) const;
 
  template <typename CreateClientVpnEndpointRequestT = Model::CreateClientVpnEndpointRequest>
  Model::CreateClientVpnEndpointOutcomeCallable CreateClientVpnEndpointCallable(const CreateClientVpnEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateClientVpnEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::CreateClientVpnRouteOutcome CreateClientVpnRoute(const Model::CreateClientVpnRouteRequest& request) const;
 
  template <typename CreateClientVpnRouteRequestT = Model::CreateClientVpnRouteRequest>
  Model::CreateClientVpnRouteOutcomeCallable CreateClientVpnRouteCallable(const CreateClientVpnRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateClientVpnRoute, request);
  }
 
  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);
  }
 
  virtual Model::CreateCoipCidrOutcome CreateCoipCidr(const Model::CreateCoipCidrRequest& request) const;
 
  template <typename CreateCoipCidrRequestT = Model::CreateCoipCidrRequest>
  Model::CreateCoipCidrOutcomeCallable CreateCoipCidrCallable(const CreateCoipCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCoipCidr, request);
  }
 
  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);
  }
 
  virtual Model::CreateCoipPoolOutcome CreateCoipPool(const Model::CreateCoipPoolRequest& request) const;
 
  template <typename CreateCoipPoolRequestT = Model::CreateCoipPoolRequest>
  Model::CreateCoipPoolOutcomeCallable CreateCoipPoolCallable(const CreateCoipPoolRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCoipPool, request);
  }
 
  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);
  }
 
  virtual Model::CreateCustomerGatewayOutcome CreateCustomerGateway(const Model::CreateCustomerGatewayRequest& request) const;
 
  template <typename CreateCustomerGatewayRequestT = Model::CreateCustomerGatewayRequest>
  Model::CreateCustomerGatewayOutcomeCallable CreateCustomerGatewayCallable(const CreateCustomerGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateCustomerGateway, request);
  }
 
  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);
  }
 
  virtual Model::CreateDefaultSubnetOutcome CreateDefaultSubnet(const Model::CreateDefaultSubnetRequest& request = {}) const;
 
  template <typename CreateDefaultSubnetRequestT = Model::CreateDefaultSubnetRequest>
  Model::CreateDefaultSubnetOutcomeCallable CreateDefaultSubnetCallable(const CreateDefaultSubnetRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateDefaultSubnet, request);
  }
 
  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);
  }
 
  virtual Model::CreateDefaultVpcOutcome CreateDefaultVpc(const Model::CreateDefaultVpcRequest& request = {}) const;
 
  template <typename CreateDefaultVpcRequestT = Model::CreateDefaultVpcRequest>
  Model::CreateDefaultVpcOutcomeCallable CreateDefaultVpcCallable(const CreateDefaultVpcRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateDefaultVpc, request);
  }
 
  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);
  }
 
  virtual Model::CreateDelegateMacVolumeOwnershipTaskOutcome CreateDelegateMacVolumeOwnershipTask(
      const Model::CreateDelegateMacVolumeOwnershipTaskRequest& request) const;
 
  template <typename CreateDelegateMacVolumeOwnershipTaskRequestT = Model::CreateDelegateMacVolumeOwnershipTaskRequest>
  Model::CreateDelegateMacVolumeOwnershipTaskOutcomeCallable CreateDelegateMacVolumeOwnershipTaskCallable(
      const CreateDelegateMacVolumeOwnershipTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateDelegateMacVolumeOwnershipTask, request);
  }
 
  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);
  }
 
  virtual Model::CreateDhcpOptionsOutcome CreateDhcpOptions(const Model::CreateDhcpOptionsRequest& request) const;
 
  template <typename CreateDhcpOptionsRequestT = Model::CreateDhcpOptionsRequest>
  Model::CreateDhcpOptionsOutcomeCallable CreateDhcpOptionsCallable(const CreateDhcpOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateDhcpOptions, request);
  }
 
  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);
  }
 
  virtual Model::CreateEgressOnlyInternetGatewayOutcome CreateEgressOnlyInternetGateway(
      const Model::CreateEgressOnlyInternetGatewayRequest& request) const;
 
  template <typename CreateEgressOnlyInternetGatewayRequestT = Model::CreateEgressOnlyInternetGatewayRequest>
  Model::CreateEgressOnlyInternetGatewayOutcomeCallable CreateEgressOnlyInternetGatewayCallable(
      const CreateEgressOnlyInternetGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateEgressOnlyInternetGateway, request);
  }
 
  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);
  }
 
  virtual Model::CreateFleetOutcome CreateFleet(const Model::CreateFleetRequest& request) const;
 
  template <typename CreateFleetRequestT = Model::CreateFleetRequest>
  Model::CreateFleetOutcomeCallable CreateFleetCallable(const CreateFleetRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateFleet, request);
  }
 
  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);
  }
 
  virtual Model::CreateFlowLogsOutcome CreateFlowLogs(const Model::CreateFlowLogsRequest& request) const;
 
  template <typename CreateFlowLogsRequestT = Model::CreateFlowLogsRequest>
  Model::CreateFlowLogsOutcomeCallable CreateFlowLogsCallable(const CreateFlowLogsRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateFlowLogs, request);
  }
 
  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);
  }
 
  virtual Model::CreateFpgaImageOutcome CreateFpgaImage(const Model::CreateFpgaImageRequest& request) const;
 
  template <typename CreateFpgaImageRequestT = Model::CreateFpgaImageRequest>
  Model::CreateFpgaImageOutcomeCallable CreateFpgaImageCallable(const CreateFpgaImageRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateFpgaImage, request);
  }
 
  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);
  }
 
  virtual Model::CreateImageOutcome CreateImage(const Model::CreateImageRequest& request) const;
 
  template <typename CreateImageRequestT = Model::CreateImageRequest>
  Model::CreateImageOutcomeCallable CreateImageCallable(const CreateImageRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateImage, request);
  }
 
  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);
  }
 
  virtual Model::CreateImageUsageReportOutcome CreateImageUsageReport(const Model::CreateImageUsageReportRequest& request) const;
 
  template <typename CreateImageUsageReportRequestT = Model::CreateImageUsageReportRequest>
  Model::CreateImageUsageReportOutcomeCallable CreateImageUsageReportCallable(const CreateImageUsageReportRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateImageUsageReport, request);
  }
 
  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);
  }
 
  virtual Model::CreateInstanceConnectEndpointOutcome CreateInstanceConnectEndpoint(
      const Model::CreateInstanceConnectEndpointRequest& request) const;
 
  template <typename CreateInstanceConnectEndpointRequestT = Model::CreateInstanceConnectEndpointRequest>
  Model::CreateInstanceConnectEndpointOutcomeCallable CreateInstanceConnectEndpointCallable(
      const CreateInstanceConnectEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateInstanceConnectEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::CreateInstanceEventWindowOutcome CreateInstanceEventWindow(
      const Model::CreateInstanceEventWindowRequest& request = {}) const;
 
  template <typename CreateInstanceEventWindowRequestT = Model::CreateInstanceEventWindowRequest>
  Model::CreateInstanceEventWindowOutcomeCallable CreateInstanceEventWindowCallable(
      const CreateInstanceEventWindowRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateInstanceEventWindow, request);
  }
 
  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);
  }
 
  virtual Model::CreateInstanceExportTaskOutcome CreateInstanceExportTask(const Model::CreateInstanceExportTaskRequest& request) const;
 
  template <typename CreateInstanceExportTaskRequestT = Model::CreateInstanceExportTaskRequest>
  Model::CreateInstanceExportTaskOutcomeCallable CreateInstanceExportTaskCallable(const CreateInstanceExportTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateInstanceExportTask, request);
  }
 
  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);
  }
 
  virtual Model::CreateInternetGatewayOutcome CreateInternetGateway(const Model::CreateInternetGatewayRequest& request = {}) const;
 
  template <typename CreateInternetGatewayRequestT = Model::CreateInternetGatewayRequest>
  Model::CreateInternetGatewayOutcomeCallable CreateInternetGatewayCallable(const CreateInternetGatewayRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateInternetGateway, request);
  }
 
  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);
  }
 
  virtual Model::CreateInterruptibleCapacityReservationAllocationOutcome CreateInterruptibleCapacityReservationAllocation(
      const Model::CreateInterruptibleCapacityReservationAllocationRequest& request) const;
 
  template <
      typename CreateInterruptibleCapacityReservationAllocationRequestT = Model::CreateInterruptibleCapacityReservationAllocationRequest>
  Model::CreateInterruptibleCapacityReservationAllocationOutcomeCallable CreateInterruptibleCapacityReservationAllocationCallable(
      const CreateInterruptibleCapacityReservationAllocationRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateInterruptibleCapacityReservationAllocation, request);
  }
 
  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);
  }
 
  virtual Model::CreateIpamOutcome CreateIpam(const Model::CreateIpamRequest& request = {}) const;
 
  template <typename CreateIpamRequestT = Model::CreateIpamRequest>
  Model::CreateIpamOutcomeCallable CreateIpamCallable(const CreateIpamRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateIpam, request);
  }
 
  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);
  }
 
  virtual Model::CreateIpamExternalResourceVerificationTokenOutcome CreateIpamExternalResourceVerificationToken(
      const Model::CreateIpamExternalResourceVerificationTokenRequest& request) const;
 
  template <typename CreateIpamExternalResourceVerificationTokenRequestT = Model::CreateIpamExternalResourceVerificationTokenRequest>
  Model::CreateIpamExternalResourceVerificationTokenOutcomeCallable CreateIpamExternalResourceVerificationTokenCallable(
      const CreateIpamExternalResourceVerificationTokenRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamExternalResourceVerificationToken, request);
  }
 
  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);
  }
 
  virtual Model::CreateIpamPolicyOutcome CreateIpamPolicy(const Model::CreateIpamPolicyRequest& request) const;
 
  template <typename CreateIpamPolicyRequestT = Model::CreateIpamPolicyRequest>
  Model::CreateIpamPolicyOutcomeCallable CreateIpamPolicyCallable(const CreateIpamPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamPolicy, request);
  }
 
  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);
  }
 
  virtual Model::CreateIpamPoolOutcome CreateIpamPool(const Model::CreateIpamPoolRequest& request) const;
 
  template <typename CreateIpamPoolRequestT = Model::CreateIpamPoolRequest>
  Model::CreateIpamPoolOutcomeCallable CreateIpamPoolCallable(const CreateIpamPoolRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamPool, request);
  }
 
  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);
  }
 
  virtual Model::CreateIpamPrefixListResolverOutcome CreateIpamPrefixListResolver(
      const Model::CreateIpamPrefixListResolverRequest& request) const;
 
  template <typename CreateIpamPrefixListResolverRequestT = Model::CreateIpamPrefixListResolverRequest>
  Model::CreateIpamPrefixListResolverOutcomeCallable CreateIpamPrefixListResolverCallable(
      const CreateIpamPrefixListResolverRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamPrefixListResolver, request);
  }
 
  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);
  }
 
  virtual Model::CreateIpamPrefixListResolverTargetOutcome CreateIpamPrefixListResolverTarget(
      const Model::CreateIpamPrefixListResolverTargetRequest& request) const;
 
  template <typename CreateIpamPrefixListResolverTargetRequestT = Model::CreateIpamPrefixListResolverTargetRequest>
  Model::CreateIpamPrefixListResolverTargetOutcomeCallable CreateIpamPrefixListResolverTargetCallable(
      const CreateIpamPrefixListResolverTargetRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamPrefixListResolverTarget, request);
  }
 
  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);
  }
 
  virtual Model::CreateIpamResourceDiscoveryOutcome CreateIpamResourceDiscovery(
      const Model::CreateIpamResourceDiscoveryRequest& request = {}) const;
 
  template <typename CreateIpamResourceDiscoveryRequestT = Model::CreateIpamResourceDiscoveryRequest>
  Model::CreateIpamResourceDiscoveryOutcomeCallable CreateIpamResourceDiscoveryCallable(
      const CreateIpamResourceDiscoveryRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateIpamResourceDiscovery, request);
  }
 
  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);
  }
 
  virtual Model::CreateIpamScopeOutcome CreateIpamScope(const Model::CreateIpamScopeRequest& request) const;
 
  template <typename CreateIpamScopeRequestT = Model::CreateIpamScopeRequest>
  Model::CreateIpamScopeOutcomeCallable CreateIpamScopeCallable(const CreateIpamScopeRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateIpamScope, request);
  }
 
  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);
  }
 
  virtual Model::CreateKeyPairOutcome CreateKeyPair(const Model::CreateKeyPairRequest& request) const;
 
  template <typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
  Model::CreateKeyPairOutcomeCallable CreateKeyPairCallable(const CreateKeyPairRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateKeyPair, request);
  }
 
  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);
  }
 
  virtual Model::CreateLaunchTemplateOutcome CreateLaunchTemplate(const Model::CreateLaunchTemplateRequest& request) const;
 
  template <typename CreateLaunchTemplateRequestT = Model::CreateLaunchTemplateRequest>
  Model::CreateLaunchTemplateOutcomeCallable CreateLaunchTemplateCallable(const CreateLaunchTemplateRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLaunchTemplate, request);
  }
 
  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);
  }
 
  virtual Model::CreateLaunchTemplateVersionOutcome CreateLaunchTemplateVersion(
      const Model::CreateLaunchTemplateVersionRequest& request) const;
 
  template <typename CreateLaunchTemplateVersionRequestT = Model::CreateLaunchTemplateVersionRequest>
  Model::CreateLaunchTemplateVersionOutcomeCallable CreateLaunchTemplateVersionCallable(
      const CreateLaunchTemplateVersionRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLaunchTemplateVersion, request);
  }
 
  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);
  }
 
  virtual Model::CreateLocalGatewayRouteOutcome CreateLocalGatewayRoute(const Model::CreateLocalGatewayRouteRequest& request) const;
 
  template <typename CreateLocalGatewayRouteRequestT = Model::CreateLocalGatewayRouteRequest>
  Model::CreateLocalGatewayRouteOutcomeCallable CreateLocalGatewayRouteCallable(const CreateLocalGatewayRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLocalGatewayRoute, request);
  }
 
  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);
  }
 
  virtual Model::CreateLocalGatewayRouteTableOutcome CreateLocalGatewayRouteTable(
      const Model::CreateLocalGatewayRouteTableRequest& request) const;
 
  template <typename CreateLocalGatewayRouteTableRequestT = Model::CreateLocalGatewayRouteTableRequest>
  Model::CreateLocalGatewayRouteTableOutcomeCallable CreateLocalGatewayRouteTableCallable(
      const CreateLocalGatewayRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLocalGatewayRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutcome
  CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(
      const Model::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest& request) const;
 
  template <typename CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT =
                Model::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest>
  Model::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutcomeCallable
  CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationCallable(
      const CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation, request);
  }
 
  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);
  }
 
  virtual Model::CreateLocalGatewayRouteTableVpcAssociationOutcome CreateLocalGatewayRouteTableVpcAssociation(
      const Model::CreateLocalGatewayRouteTableVpcAssociationRequest& request) const;
 
  template <typename CreateLocalGatewayRouteTableVpcAssociationRequestT = Model::CreateLocalGatewayRouteTableVpcAssociationRequest>
  Model::CreateLocalGatewayRouteTableVpcAssociationOutcomeCallable CreateLocalGatewayRouteTableVpcAssociationCallable(
      const CreateLocalGatewayRouteTableVpcAssociationRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLocalGatewayRouteTableVpcAssociation, request);
  }
 
  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);
  }
 
  virtual Model::CreateLocalGatewayVirtualInterfaceOutcome CreateLocalGatewayVirtualInterface(
      const Model::CreateLocalGatewayVirtualInterfaceRequest& request) const;
 
  template <typename CreateLocalGatewayVirtualInterfaceRequestT = Model::CreateLocalGatewayVirtualInterfaceRequest>
  Model::CreateLocalGatewayVirtualInterfaceOutcomeCallable CreateLocalGatewayVirtualInterfaceCallable(
      const CreateLocalGatewayVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLocalGatewayVirtualInterface, request);
  }
 
  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);
  }
 
  virtual Model::CreateLocalGatewayVirtualInterfaceGroupOutcome CreateLocalGatewayVirtualInterfaceGroup(
      const Model::CreateLocalGatewayVirtualInterfaceGroupRequest& request) const;
 
  template <typename CreateLocalGatewayVirtualInterfaceGroupRequestT = Model::CreateLocalGatewayVirtualInterfaceGroupRequest>
  Model::CreateLocalGatewayVirtualInterfaceGroupOutcomeCallable CreateLocalGatewayVirtualInterfaceGroupCallable(
      const CreateLocalGatewayVirtualInterfaceGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateLocalGatewayVirtualInterfaceGroup, request);
  }
 
  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);
  }
 
  virtual Model::CreateMacSystemIntegrityProtectionModificationTaskOutcome CreateMacSystemIntegrityProtectionModificationTask(
      const Model::CreateMacSystemIntegrityProtectionModificationTaskRequest& request) const;
 
  template <typename CreateMacSystemIntegrityProtectionModificationTaskRequestT =
                Model::CreateMacSystemIntegrityProtectionModificationTaskRequest>
  Model::CreateMacSystemIntegrityProtectionModificationTaskOutcomeCallable CreateMacSystemIntegrityProtectionModificationTaskCallable(
      const CreateMacSystemIntegrityProtectionModificationTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateMacSystemIntegrityProtectionModificationTask, request);
  }
 
  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);
  }
 
  virtual Model::CreateManagedPrefixListOutcome CreateManagedPrefixList(const Model::CreateManagedPrefixListRequest& request) const;
 
  template <typename CreateManagedPrefixListRequestT = Model::CreateManagedPrefixListRequest>
  Model::CreateManagedPrefixListOutcomeCallable CreateManagedPrefixListCallable(const CreateManagedPrefixListRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateManagedPrefixList, request);
  }
 
  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);
  }
 
  virtual Model::CreateNatGatewayOutcome CreateNatGateway(const Model::CreateNatGatewayRequest& request = {}) const;
 
  template <typename CreateNatGatewayRequestT = Model::CreateNatGatewayRequest>
  Model::CreateNatGatewayOutcomeCallable CreateNatGatewayCallable(const CreateNatGatewayRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateNatGateway, request);
  }
 
  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);
  }
 
  virtual Model::CreateNetworkAclOutcome CreateNetworkAcl(const Model::CreateNetworkAclRequest& request) const;
 
  template <typename CreateNetworkAclRequestT = Model::CreateNetworkAclRequest>
  Model::CreateNetworkAclOutcomeCallable CreateNetworkAclCallable(const CreateNetworkAclRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateNetworkAcl, request);
  }
 
  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);
  }
 
  virtual Model::CreateNetworkAclEntryOutcome CreateNetworkAclEntry(const Model::CreateNetworkAclEntryRequest& request) const;
 
  template <typename CreateNetworkAclEntryRequestT = Model::CreateNetworkAclEntryRequest>
  Model::CreateNetworkAclEntryOutcomeCallable CreateNetworkAclEntryCallable(const CreateNetworkAclEntryRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateNetworkAclEntry, request);
  }
 
  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);
  }
 
  virtual Model::CreateNetworkInsightsAccessScopeOutcome CreateNetworkInsightsAccessScope(
      const Model::CreateNetworkInsightsAccessScopeRequest& request) const;
 
  template <typename CreateNetworkInsightsAccessScopeRequestT = Model::CreateNetworkInsightsAccessScopeRequest>
  Model::CreateNetworkInsightsAccessScopeOutcomeCallable CreateNetworkInsightsAccessScopeCallable(
      const CreateNetworkInsightsAccessScopeRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateNetworkInsightsAccessScope, request);
  }
 
  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);
  }
 
  virtual Model::CreateNetworkInsightsPathOutcome CreateNetworkInsightsPath(const Model::CreateNetworkInsightsPathRequest& request) const;
 
  template <typename CreateNetworkInsightsPathRequestT = Model::CreateNetworkInsightsPathRequest>
  Model::CreateNetworkInsightsPathOutcomeCallable CreateNetworkInsightsPathCallable(
      const CreateNetworkInsightsPathRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateNetworkInsightsPath, request);
  }
 
  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);
  }
 
  virtual Model::CreateNetworkInterfaceOutcome CreateNetworkInterface(const Model::CreateNetworkInterfaceRequest& request) const;
 
  template <typename CreateNetworkInterfaceRequestT = Model::CreateNetworkInterfaceRequest>
  Model::CreateNetworkInterfaceOutcomeCallable CreateNetworkInterfaceCallable(const CreateNetworkInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateNetworkInterface, request);
  }
 
  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);
  }
 
  virtual Model::CreateNetworkInterfacePermissionOutcome CreateNetworkInterfacePermission(
      const Model::CreateNetworkInterfacePermissionRequest& request) const;
 
  template <typename CreateNetworkInterfacePermissionRequestT = Model::CreateNetworkInterfacePermissionRequest>
  Model::CreateNetworkInterfacePermissionOutcomeCallable CreateNetworkInterfacePermissionCallable(
      const CreateNetworkInterfacePermissionRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateNetworkInterfacePermission, request);
  }
 
  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);
  }
 
  virtual Model::CreatePlacementGroupOutcome CreatePlacementGroup(const Model::CreatePlacementGroupRequest& request = {}) const;
 
  template <typename CreatePlacementGroupRequestT = Model::CreatePlacementGroupRequest>
  Model::CreatePlacementGroupOutcomeCallable CreatePlacementGroupCallable(const CreatePlacementGroupRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreatePlacementGroup, request);
  }
 
  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);
  }
 
  virtual Model::CreatePublicIpv4PoolOutcome CreatePublicIpv4Pool(const Model::CreatePublicIpv4PoolRequest& request = {}) const;
 
  template <typename CreatePublicIpv4PoolRequestT = Model::CreatePublicIpv4PoolRequest>
  Model::CreatePublicIpv4PoolOutcomeCallable CreatePublicIpv4PoolCallable(const CreatePublicIpv4PoolRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreatePublicIpv4Pool, request);
  }
 
  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);
  }
 
  virtual Model::CreateReplaceRootVolumeTaskOutcome CreateReplaceRootVolumeTask(
      const Model::CreateReplaceRootVolumeTaskRequest& request) const;
 
  template <typename CreateReplaceRootVolumeTaskRequestT = Model::CreateReplaceRootVolumeTaskRequest>
  Model::CreateReplaceRootVolumeTaskOutcomeCallable CreateReplaceRootVolumeTaskCallable(
      const CreateReplaceRootVolumeTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateReplaceRootVolumeTask, request);
  }
 
  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);
  }
 
  virtual Model::CreateReservedInstancesListingOutcome CreateReservedInstancesListing(
      const Model::CreateReservedInstancesListingRequest& request) const;
 
  template <typename CreateReservedInstancesListingRequestT = Model::CreateReservedInstancesListingRequest>
  Model::CreateReservedInstancesListingOutcomeCallable CreateReservedInstancesListingCallable(
      const CreateReservedInstancesListingRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateReservedInstancesListing, request);
  }
 
  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);
  }
 
  virtual Model::CreateRestoreImageTaskOutcome CreateRestoreImageTask(const Model::CreateRestoreImageTaskRequest& request) const;
 
  template <typename CreateRestoreImageTaskRequestT = Model::CreateRestoreImageTaskRequest>
  Model::CreateRestoreImageTaskOutcomeCallable CreateRestoreImageTaskCallable(const CreateRestoreImageTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateRestoreImageTask, request);
  }
 
  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);
  }
 
  virtual Model::CreateRouteOutcome CreateRoute(const Model::CreateRouteRequest& request) const;
 
  template <typename CreateRouteRequestT = Model::CreateRouteRequest>
  Model::CreateRouteOutcomeCallable CreateRouteCallable(const CreateRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateRoute, request);
  }
 
  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);
  }
 
  virtual Model::CreateRouteServerOutcome CreateRouteServer(const Model::CreateRouteServerRequest& request) const;
 
  template <typename CreateRouteServerRequestT = Model::CreateRouteServerRequest>
  Model::CreateRouteServerOutcomeCallable CreateRouteServerCallable(const CreateRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateRouteServer, request);
  }
 
  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);
  }
 
  virtual Model::CreateRouteServerEndpointOutcome CreateRouteServerEndpoint(const Model::CreateRouteServerEndpointRequest& request) const;
 
  template <typename CreateRouteServerEndpointRequestT = Model::CreateRouteServerEndpointRequest>
  Model::CreateRouteServerEndpointOutcomeCallable CreateRouteServerEndpointCallable(
      const CreateRouteServerEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateRouteServerEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::CreateRouteServerPeerOutcome CreateRouteServerPeer(const Model::CreateRouteServerPeerRequest& request) const;
 
  template <typename CreateRouteServerPeerRequestT = Model::CreateRouteServerPeerRequest>
  Model::CreateRouteServerPeerOutcomeCallable CreateRouteServerPeerCallable(const CreateRouteServerPeerRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateRouteServerPeer, request);
  }
 
  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);
  }
 
  virtual Model::CreateRouteTableOutcome CreateRouteTable(const Model::CreateRouteTableRequest& request) const;
 
  template <typename CreateRouteTableRequestT = Model::CreateRouteTableRequest>
  Model::CreateRouteTableOutcomeCallable CreateRouteTableCallable(const CreateRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::CreateSecondaryNetworkOutcome CreateSecondaryNetwork(const Model::CreateSecondaryNetworkRequest& request) const;
 
  template <typename CreateSecondaryNetworkRequestT = Model::CreateSecondaryNetworkRequest>
  Model::CreateSecondaryNetworkOutcomeCallable CreateSecondaryNetworkCallable(const CreateSecondaryNetworkRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSecondaryNetwork, request);
  }
 
  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);
  }
 
  virtual Model::CreateSecondarySubnetOutcome CreateSecondarySubnet(const Model::CreateSecondarySubnetRequest& request) const;
 
  template <typename CreateSecondarySubnetRequestT = Model::CreateSecondarySubnetRequest>
  Model::CreateSecondarySubnetOutcomeCallable CreateSecondarySubnetCallable(const CreateSecondarySubnetRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSecondarySubnet, request);
  }
 
  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);
  }
 
  virtual Model::CreateSecurityGroupOutcome CreateSecurityGroup(const Model::CreateSecurityGroupRequest& request) const;
 
  template <typename CreateSecurityGroupRequestT = Model::CreateSecurityGroupRequest>
  Model::CreateSecurityGroupOutcomeCallable CreateSecurityGroupCallable(const CreateSecurityGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSecurityGroup, request);
  }
 
  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);
  }
 
  virtual Model::CreateSnapshotOutcome CreateSnapshot(const Model::CreateSnapshotRequest& request) const;
 
  template <typename CreateSnapshotRequestT = Model::CreateSnapshotRequest>
  Model::CreateSnapshotOutcomeCallable CreateSnapshotCallable(const CreateSnapshotRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSnapshot, request);
  }
 
  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);
  }
 
  virtual Model::CreateSnapshotsOutcome CreateSnapshots(const Model::CreateSnapshotsRequest& request) const;
 
  template <typename CreateSnapshotsRequestT = Model::CreateSnapshotsRequest>
  Model::CreateSnapshotsOutcomeCallable CreateSnapshotsCallable(const CreateSnapshotsRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSnapshots, request);
  }
 
  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);
  }
 
  virtual Model::CreateSpotDatafeedSubscriptionOutcome CreateSpotDatafeedSubscription(
      const Model::CreateSpotDatafeedSubscriptionRequest& request) const;
 
  template <typename CreateSpotDatafeedSubscriptionRequestT = Model::CreateSpotDatafeedSubscriptionRequest>
  Model::CreateSpotDatafeedSubscriptionOutcomeCallable CreateSpotDatafeedSubscriptionCallable(
      const CreateSpotDatafeedSubscriptionRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSpotDatafeedSubscription, request);
  }
 
  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);
  }
 
  virtual Model::CreateStoreImageTaskOutcome CreateStoreImageTask(const Model::CreateStoreImageTaskRequest& request) const;
 
  template <typename CreateStoreImageTaskRequestT = Model::CreateStoreImageTaskRequest>
  Model::CreateStoreImageTaskOutcomeCallable CreateStoreImageTaskCallable(const CreateStoreImageTaskRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateStoreImageTask, request);
  }
 
  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);
  }
 
  virtual Model::CreateSubnetOutcome CreateSubnet(const Model::CreateSubnetRequest& request) const;
 
  template <typename CreateSubnetRequestT = Model::CreateSubnetRequest>
  Model::CreateSubnetOutcomeCallable CreateSubnetCallable(const CreateSubnetRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSubnet, request);
  }
 
  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);
  }
 
  virtual Model::CreateSubnetCidrReservationOutcome CreateSubnetCidrReservation(
      const Model::CreateSubnetCidrReservationRequest& request) const;
 
  template <typename CreateSubnetCidrReservationRequestT = Model::CreateSubnetCidrReservationRequest>
  Model::CreateSubnetCidrReservationOutcomeCallable CreateSubnetCidrReservationCallable(
      const CreateSubnetCidrReservationRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateSubnetCidrReservation, request);
  }
 
  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);
  }
 
  virtual Model::CreateTagsOutcome CreateTags(const Model::CreateTagsRequest& request) const;
 
  template <typename CreateTagsRequestT = Model::CreateTagsRequest>
  Model::CreateTagsOutcomeCallable CreateTagsCallable(const CreateTagsRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTags, request);
  }
 
  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);
  }
 
  virtual Model::CreateTrafficMirrorFilterOutcome CreateTrafficMirrorFilter(
      const Model::CreateTrafficMirrorFilterRequest& request = {}) const;
 
  template <typename CreateTrafficMirrorFilterRequestT = Model::CreateTrafficMirrorFilterRequest>
  Model::CreateTrafficMirrorFilterOutcomeCallable CreateTrafficMirrorFilterCallable(
      const CreateTrafficMirrorFilterRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateTrafficMirrorFilter, request);
  }
 
  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);
  }
 
  virtual Model::CreateTrafficMirrorFilterRuleOutcome CreateTrafficMirrorFilterRule(
      const Model::CreateTrafficMirrorFilterRuleRequest& request) const;
 
  template <typename CreateTrafficMirrorFilterRuleRequestT = Model::CreateTrafficMirrorFilterRuleRequest>
  Model::CreateTrafficMirrorFilterRuleOutcomeCallable CreateTrafficMirrorFilterRuleCallable(
      const CreateTrafficMirrorFilterRuleRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTrafficMirrorFilterRule, request);
  }
 
  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);
  }
 
  virtual Model::CreateTrafficMirrorSessionOutcome CreateTrafficMirrorSession(
      const Model::CreateTrafficMirrorSessionRequest& request) const;
 
  template <typename CreateTrafficMirrorSessionRequestT = Model::CreateTrafficMirrorSessionRequest>
  Model::CreateTrafficMirrorSessionOutcomeCallable CreateTrafficMirrorSessionCallable(
      const CreateTrafficMirrorSessionRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTrafficMirrorSession, request);
  }
 
  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);
  }
 
  virtual Model::CreateTrafficMirrorTargetOutcome CreateTrafficMirrorTarget(
      const Model::CreateTrafficMirrorTargetRequest& request = {}) const;
 
  template <typename CreateTrafficMirrorTargetRequestT = Model::CreateTrafficMirrorTargetRequest>
  Model::CreateTrafficMirrorTargetOutcomeCallable CreateTrafficMirrorTargetCallable(
      const CreateTrafficMirrorTargetRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateTrafficMirrorTarget, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayOutcome CreateTransitGateway(const Model::CreateTransitGatewayRequest& request = {}) const;
 
  template <typename CreateTransitGatewayRequestT = Model::CreateTransitGatewayRequest>
  Model::CreateTransitGatewayOutcomeCallable CreateTransitGatewayCallable(const CreateTransitGatewayRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateTransitGateway, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayConnectOutcome CreateTransitGatewayConnect(
      const Model::CreateTransitGatewayConnectRequest& request) const;
 
  template <typename CreateTransitGatewayConnectRequestT = Model::CreateTransitGatewayConnectRequest>
  Model::CreateTransitGatewayConnectOutcomeCallable CreateTransitGatewayConnectCallable(
      const CreateTransitGatewayConnectRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayConnect, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayConnectPeerOutcome CreateTransitGatewayConnectPeer(
      const Model::CreateTransitGatewayConnectPeerRequest& request) const;
 
  template <typename CreateTransitGatewayConnectPeerRequestT = Model::CreateTransitGatewayConnectPeerRequest>
  Model::CreateTransitGatewayConnectPeerOutcomeCallable CreateTransitGatewayConnectPeerCallable(
      const CreateTransitGatewayConnectPeerRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayConnectPeer, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayMeteringPolicyOutcome CreateTransitGatewayMeteringPolicy(
      const Model::CreateTransitGatewayMeteringPolicyRequest& request) const;
 
  template <typename CreateTransitGatewayMeteringPolicyRequestT = Model::CreateTransitGatewayMeteringPolicyRequest>
  Model::CreateTransitGatewayMeteringPolicyOutcomeCallable CreateTransitGatewayMeteringPolicyCallable(
      const CreateTransitGatewayMeteringPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayMeteringPolicy, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayMeteringPolicyEntryOutcome CreateTransitGatewayMeteringPolicyEntry(
      const Model::CreateTransitGatewayMeteringPolicyEntryRequest& request) const;
 
  template <typename CreateTransitGatewayMeteringPolicyEntryRequestT = Model::CreateTransitGatewayMeteringPolicyEntryRequest>
  Model::CreateTransitGatewayMeteringPolicyEntryOutcomeCallable CreateTransitGatewayMeteringPolicyEntryCallable(
      const CreateTransitGatewayMeteringPolicyEntryRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayMeteringPolicyEntry, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayMulticastDomainOutcome CreateTransitGatewayMulticastDomain(
      const Model::CreateTransitGatewayMulticastDomainRequest& request) const;
 
  template <typename CreateTransitGatewayMulticastDomainRequestT = Model::CreateTransitGatewayMulticastDomainRequest>
  Model::CreateTransitGatewayMulticastDomainOutcomeCallable CreateTransitGatewayMulticastDomainCallable(
      const CreateTransitGatewayMulticastDomainRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayMulticastDomain, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayPeeringAttachmentOutcome CreateTransitGatewayPeeringAttachment(
      const Model::CreateTransitGatewayPeeringAttachmentRequest& request) const;
 
  template <typename CreateTransitGatewayPeeringAttachmentRequestT = Model::CreateTransitGatewayPeeringAttachmentRequest>
  Model::CreateTransitGatewayPeeringAttachmentOutcomeCallable CreateTransitGatewayPeeringAttachmentCallable(
      const CreateTransitGatewayPeeringAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayPeeringAttachment, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayPolicyTableOutcome CreateTransitGatewayPolicyTable(
      const Model::CreateTransitGatewayPolicyTableRequest& request) const;
 
  template <typename CreateTransitGatewayPolicyTableRequestT = Model::CreateTransitGatewayPolicyTableRequest>
  Model::CreateTransitGatewayPolicyTableOutcomeCallable CreateTransitGatewayPolicyTableCallable(
      const CreateTransitGatewayPolicyTableRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayPolicyTable, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayPrefixListReferenceOutcome CreateTransitGatewayPrefixListReference(
      const Model::CreateTransitGatewayPrefixListReferenceRequest& request) const;
 
  template <typename CreateTransitGatewayPrefixListReferenceRequestT = Model::CreateTransitGatewayPrefixListReferenceRequest>
  Model::CreateTransitGatewayPrefixListReferenceOutcomeCallable CreateTransitGatewayPrefixListReferenceCallable(
      const CreateTransitGatewayPrefixListReferenceRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayPrefixListReference, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayRouteOutcome CreateTransitGatewayRoute(const Model::CreateTransitGatewayRouteRequest& request) const;
 
  template <typename CreateTransitGatewayRouteRequestT = Model::CreateTransitGatewayRouteRequest>
  Model::CreateTransitGatewayRouteOutcomeCallable CreateTransitGatewayRouteCallable(
      const CreateTransitGatewayRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayRoute, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayRouteTableOutcome CreateTransitGatewayRouteTable(
      const Model::CreateTransitGatewayRouteTableRequest& request) const;
 
  template <typename CreateTransitGatewayRouteTableRequestT = Model::CreateTransitGatewayRouteTableRequest>
  Model::CreateTransitGatewayRouteTableOutcomeCallable CreateTransitGatewayRouteTableCallable(
      const CreateTransitGatewayRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayRouteTableAnnouncementOutcome CreateTransitGatewayRouteTableAnnouncement(
      const Model::CreateTransitGatewayRouteTableAnnouncementRequest& request) const;
 
  template <typename CreateTransitGatewayRouteTableAnnouncementRequestT = Model::CreateTransitGatewayRouteTableAnnouncementRequest>
  Model::CreateTransitGatewayRouteTableAnnouncementOutcomeCallable CreateTransitGatewayRouteTableAnnouncementCallable(
      const CreateTransitGatewayRouteTableAnnouncementRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayRouteTableAnnouncement, request);
  }
 
  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);
  }
 
  virtual Model::CreateTransitGatewayVpcAttachmentOutcome CreateTransitGatewayVpcAttachment(
      const Model::CreateTransitGatewayVpcAttachmentRequest& request) const;
 
  template <typename CreateTransitGatewayVpcAttachmentRequestT = Model::CreateTransitGatewayVpcAttachmentRequest>
  Model::CreateTransitGatewayVpcAttachmentOutcomeCallable CreateTransitGatewayVpcAttachmentCallable(
      const CreateTransitGatewayVpcAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateTransitGatewayVpcAttachment, request);
  }
 
  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);
  }
 
  virtual Model::CreateVerifiedAccessEndpointOutcome CreateVerifiedAccessEndpoint(
      const Model::CreateVerifiedAccessEndpointRequest& request) const;
 
  template <typename CreateVerifiedAccessEndpointRequestT = Model::CreateVerifiedAccessEndpointRequest>
  Model::CreateVerifiedAccessEndpointOutcomeCallable CreateVerifiedAccessEndpointCallable(
      const CreateVerifiedAccessEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVerifiedAccessEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::CreateVerifiedAccessGroupOutcome CreateVerifiedAccessGroup(const Model::CreateVerifiedAccessGroupRequest& request) const;
 
  template <typename CreateVerifiedAccessGroupRequestT = Model::CreateVerifiedAccessGroupRequest>
  Model::CreateVerifiedAccessGroupOutcomeCallable CreateVerifiedAccessGroupCallable(
      const CreateVerifiedAccessGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVerifiedAccessGroup, request);
  }
 
  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);
  }
 
  virtual Model::CreateVerifiedAccessInstanceOutcome CreateVerifiedAccessInstance(
      const Model::CreateVerifiedAccessInstanceRequest& request = {}) const;
 
  template <typename CreateVerifiedAccessInstanceRequestT = Model::CreateVerifiedAccessInstanceRequest>
  Model::CreateVerifiedAccessInstanceOutcomeCallable CreateVerifiedAccessInstanceCallable(
      const CreateVerifiedAccessInstanceRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateVerifiedAccessInstance, request);
  }
 
  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);
  }
 
  virtual Model::CreateVerifiedAccessTrustProviderOutcome CreateVerifiedAccessTrustProvider(
      const Model::CreateVerifiedAccessTrustProviderRequest& request) const;
 
  template <typename CreateVerifiedAccessTrustProviderRequestT = Model::CreateVerifiedAccessTrustProviderRequest>
  Model::CreateVerifiedAccessTrustProviderOutcomeCallable CreateVerifiedAccessTrustProviderCallable(
      const CreateVerifiedAccessTrustProviderRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVerifiedAccessTrustProvider, request);
  }
 
  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);
  }
 
  virtual Model::CreateVolumeOutcome CreateVolume(const Model::CreateVolumeRequest& request = {}) const;
 
  template <typename CreateVolumeRequestT = Model::CreateVolumeRequest>
  Model::CreateVolumeOutcomeCallable CreateVolumeCallable(const CreateVolumeRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateVolume, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpcOutcome CreateVpc(const Model::CreateVpcRequest& request = {}) const;
 
  template <typename CreateVpcRequestT = Model::CreateVpcRequest>
  Model::CreateVpcOutcomeCallable CreateVpcCallable(const CreateVpcRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateVpc, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpcBlockPublicAccessExclusionOutcome CreateVpcBlockPublicAccessExclusion(
      const Model::CreateVpcBlockPublicAccessExclusionRequest& request) const;
 
  template <typename CreateVpcBlockPublicAccessExclusionRequestT = Model::CreateVpcBlockPublicAccessExclusionRequest>
  Model::CreateVpcBlockPublicAccessExclusionOutcomeCallable CreateVpcBlockPublicAccessExclusionCallable(
      const CreateVpcBlockPublicAccessExclusionRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpcBlockPublicAccessExclusion, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpcEncryptionControlOutcome CreateVpcEncryptionControl(
      const Model::CreateVpcEncryptionControlRequest& request) const;
 
  template <typename CreateVpcEncryptionControlRequestT = Model::CreateVpcEncryptionControlRequest>
  Model::CreateVpcEncryptionControlOutcomeCallable CreateVpcEncryptionControlCallable(
      const CreateVpcEncryptionControlRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpcEncryptionControl, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpcEndpointOutcome CreateVpcEndpoint(const Model::CreateVpcEndpointRequest& request) const;
 
  template <typename CreateVpcEndpointRequestT = Model::CreateVpcEndpointRequest>
  Model::CreateVpcEndpointOutcomeCallable CreateVpcEndpointCallable(const CreateVpcEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpcEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpcEndpointConnectionNotificationOutcome CreateVpcEndpointConnectionNotification(
      const Model::CreateVpcEndpointConnectionNotificationRequest& request) const;
 
  template <typename CreateVpcEndpointConnectionNotificationRequestT = Model::CreateVpcEndpointConnectionNotificationRequest>
  Model::CreateVpcEndpointConnectionNotificationOutcomeCallable CreateVpcEndpointConnectionNotificationCallable(
      const CreateVpcEndpointConnectionNotificationRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpcEndpointConnectionNotification, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpcEndpointServiceConfigurationOutcome CreateVpcEndpointServiceConfiguration(
      const Model::CreateVpcEndpointServiceConfigurationRequest& request = {}) const;
 
  template <typename CreateVpcEndpointServiceConfigurationRequestT = Model::CreateVpcEndpointServiceConfigurationRequest>
  Model::CreateVpcEndpointServiceConfigurationOutcomeCallable CreateVpcEndpointServiceConfigurationCallable(
      const CreateVpcEndpointServiceConfigurationRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::CreateVpcEndpointServiceConfiguration, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpcPeeringConnectionOutcome CreateVpcPeeringConnection(
      const Model::CreateVpcPeeringConnectionRequest& request) const;
 
  template <typename CreateVpcPeeringConnectionRequestT = Model::CreateVpcPeeringConnectionRequest>
  Model::CreateVpcPeeringConnectionOutcomeCallable CreateVpcPeeringConnectionCallable(
      const CreateVpcPeeringConnectionRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpcPeeringConnection, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpnConcentratorOutcome CreateVpnConcentrator(const Model::CreateVpnConcentratorRequest& request) const;
 
  template <typename CreateVpnConcentratorRequestT = Model::CreateVpnConcentratorRequest>
  Model::CreateVpnConcentratorOutcomeCallable CreateVpnConcentratorCallable(const CreateVpnConcentratorRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpnConcentrator, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpnConnectionOutcome CreateVpnConnection(const Model::CreateVpnConnectionRequest& request) const;
 
  template <typename CreateVpnConnectionRequestT = Model::CreateVpnConnectionRequest>
  Model::CreateVpnConnectionOutcomeCallable CreateVpnConnectionCallable(const CreateVpnConnectionRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpnConnection, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpnConnectionRouteOutcome CreateVpnConnectionRoute(const Model::CreateVpnConnectionRouteRequest& request) const;
 
  template <typename CreateVpnConnectionRouteRequestT = Model::CreateVpnConnectionRouteRequest>
  Model::CreateVpnConnectionRouteOutcomeCallable CreateVpnConnectionRouteCallable(const CreateVpnConnectionRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpnConnectionRoute, request);
  }
 
  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);
  }
 
  virtual Model::CreateVpnGatewayOutcome CreateVpnGateway(const Model::CreateVpnGatewayRequest& request) const;
 
  template <typename CreateVpnGatewayRequestT = Model::CreateVpnGatewayRequest>
  Model::CreateVpnGatewayOutcomeCallable CreateVpnGatewayCallable(const CreateVpnGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::CreateVpnGateway, request);
  }
 
  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);
  }
 
  virtual Model::DeleteCapacityManagerDataExportOutcome DeleteCapacityManagerDataExport(
      const Model::DeleteCapacityManagerDataExportRequest& request) const;
 
  template <typename DeleteCapacityManagerDataExportRequestT = Model::DeleteCapacityManagerDataExportRequest>
  Model::DeleteCapacityManagerDataExportOutcomeCallable DeleteCapacityManagerDataExportCallable(
      const DeleteCapacityManagerDataExportRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteCapacityManagerDataExport, request);
  }
 
  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);
  }
 
  virtual Model::DeleteCarrierGatewayOutcome DeleteCarrierGateway(const Model::DeleteCarrierGatewayRequest& request) const;
 
  template <typename DeleteCarrierGatewayRequestT = Model::DeleteCarrierGatewayRequest>
  Model::DeleteCarrierGatewayOutcomeCallable DeleteCarrierGatewayCallable(const DeleteCarrierGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteCarrierGateway, request);
  }
 
  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);
  }
 
  virtual Model::DeleteClientVpnEndpointOutcome DeleteClientVpnEndpoint(const Model::DeleteClientVpnEndpointRequest& request) const;
 
  template <typename DeleteClientVpnEndpointRequestT = Model::DeleteClientVpnEndpointRequest>
  Model::DeleteClientVpnEndpointOutcomeCallable DeleteClientVpnEndpointCallable(const DeleteClientVpnEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteClientVpnEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::DeleteClientVpnRouteOutcome DeleteClientVpnRoute(const Model::DeleteClientVpnRouteRequest& request) const;
 
  template <typename DeleteClientVpnRouteRequestT = Model::DeleteClientVpnRouteRequest>
  Model::DeleteClientVpnRouteOutcomeCallable DeleteClientVpnRouteCallable(const DeleteClientVpnRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteClientVpnRoute, request);
  }
 
  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);
  }
 
  virtual Model::DeleteCoipCidrOutcome DeleteCoipCidr(const Model::DeleteCoipCidrRequest& request) const;
 
  template <typename DeleteCoipCidrRequestT = Model::DeleteCoipCidrRequest>
  Model::DeleteCoipCidrOutcomeCallable DeleteCoipCidrCallable(const DeleteCoipCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteCoipCidr, request);
  }
 
  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);
  }
 
  virtual Model::DeleteCoipPoolOutcome DeleteCoipPool(const Model::DeleteCoipPoolRequest& request) const;
 
  template <typename DeleteCoipPoolRequestT = Model::DeleteCoipPoolRequest>
  Model::DeleteCoipPoolOutcomeCallable DeleteCoipPoolCallable(const DeleteCoipPoolRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteCoipPool, request);
  }
 
  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);
  }
 
  virtual Model::DeleteCustomerGatewayOutcome DeleteCustomerGateway(const Model::DeleteCustomerGatewayRequest& request) const;
 
  template <typename DeleteCustomerGatewayRequestT = Model::DeleteCustomerGatewayRequest>
  Model::DeleteCustomerGatewayOutcomeCallable DeleteCustomerGatewayCallable(const DeleteCustomerGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteCustomerGateway, request);
  }
 
  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);
  }
 
  virtual Model::DeleteDhcpOptionsOutcome DeleteDhcpOptions(const Model::DeleteDhcpOptionsRequest& request) const;
 
  template <typename DeleteDhcpOptionsRequestT = Model::DeleteDhcpOptionsRequest>
  Model::DeleteDhcpOptionsOutcomeCallable DeleteDhcpOptionsCallable(const DeleteDhcpOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteDhcpOptions, request);
  }
 
  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);
  }
 
  virtual Model::DeleteEgressOnlyInternetGatewayOutcome DeleteEgressOnlyInternetGateway(
      const Model::DeleteEgressOnlyInternetGatewayRequest& request) const;
 
  template <typename DeleteEgressOnlyInternetGatewayRequestT = Model::DeleteEgressOnlyInternetGatewayRequest>
  Model::DeleteEgressOnlyInternetGatewayOutcomeCallable DeleteEgressOnlyInternetGatewayCallable(
      const DeleteEgressOnlyInternetGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteEgressOnlyInternetGateway, request);
  }
 
  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);
  }
 
  virtual Model::DeleteFleetsOutcome DeleteFleets(const Model::DeleteFleetsRequest& request) const;
 
  template <typename DeleteFleetsRequestT = Model::DeleteFleetsRequest>
  Model::DeleteFleetsOutcomeCallable DeleteFleetsCallable(const DeleteFleetsRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteFleets, request);
  }
 
  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);
  }
 
  virtual Model::DeleteFlowLogsOutcome DeleteFlowLogs(const Model::DeleteFlowLogsRequest& request) const;
 
  template <typename DeleteFlowLogsRequestT = Model::DeleteFlowLogsRequest>
  Model::DeleteFlowLogsOutcomeCallable DeleteFlowLogsCallable(const DeleteFlowLogsRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteFlowLogs, request);
  }
 
  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);
  }
 
  virtual Model::DeleteFpgaImageOutcome DeleteFpgaImage(const Model::DeleteFpgaImageRequest& request) const;
 
  template <typename DeleteFpgaImageRequestT = Model::DeleteFpgaImageRequest>
  Model::DeleteFpgaImageOutcomeCallable DeleteFpgaImageCallable(const DeleteFpgaImageRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteFpgaImage, request);
  }
 
  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);
  }
 
  virtual Model::DeleteImageUsageReportOutcome DeleteImageUsageReport(const Model::DeleteImageUsageReportRequest& request) const;
 
  template <typename DeleteImageUsageReportRequestT = Model::DeleteImageUsageReportRequest>
  Model::DeleteImageUsageReportOutcomeCallable DeleteImageUsageReportCallable(const DeleteImageUsageReportRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteImageUsageReport, request);
  }
 
  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);
  }
 
  virtual Model::DeleteInstanceConnectEndpointOutcome DeleteInstanceConnectEndpoint(
      const Model::DeleteInstanceConnectEndpointRequest& request) const;
 
  template <typename DeleteInstanceConnectEndpointRequestT = Model::DeleteInstanceConnectEndpointRequest>
  Model::DeleteInstanceConnectEndpointOutcomeCallable DeleteInstanceConnectEndpointCallable(
      const DeleteInstanceConnectEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteInstanceConnectEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::DeleteInstanceEventWindowOutcome DeleteInstanceEventWindow(const Model::DeleteInstanceEventWindowRequest& request) const;
 
  template <typename DeleteInstanceEventWindowRequestT = Model::DeleteInstanceEventWindowRequest>
  Model::DeleteInstanceEventWindowOutcomeCallable DeleteInstanceEventWindowCallable(
      const DeleteInstanceEventWindowRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteInstanceEventWindow, request);
  }
 
  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);
  }
 
  virtual Model::DeleteInternetGatewayOutcome DeleteInternetGateway(const Model::DeleteInternetGatewayRequest& request) const;
 
  template <typename DeleteInternetGatewayRequestT = Model::DeleteInternetGatewayRequest>
  Model::DeleteInternetGatewayOutcomeCallable DeleteInternetGatewayCallable(const DeleteInternetGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteInternetGateway, request);
  }
 
  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);
  }
 
  virtual Model::DeleteIpamOutcome DeleteIpam(const Model::DeleteIpamRequest& request) const;
 
  template <typename DeleteIpamRequestT = Model::DeleteIpamRequest>
  Model::DeleteIpamOutcomeCallable DeleteIpamCallable(const DeleteIpamRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpam, request);
  }
 
  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);
  }
 
  virtual Model::DeleteIpamExternalResourceVerificationTokenOutcome DeleteIpamExternalResourceVerificationToken(
      const Model::DeleteIpamExternalResourceVerificationTokenRequest& request) const;
 
  template <typename DeleteIpamExternalResourceVerificationTokenRequestT = Model::DeleteIpamExternalResourceVerificationTokenRequest>
  Model::DeleteIpamExternalResourceVerificationTokenOutcomeCallable DeleteIpamExternalResourceVerificationTokenCallable(
      const DeleteIpamExternalResourceVerificationTokenRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamExternalResourceVerificationToken, request);
  }
 
  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);
  }
 
  virtual Model::DeleteIpamPolicyOutcome DeleteIpamPolicy(const Model::DeleteIpamPolicyRequest& request) const;
 
  template <typename DeleteIpamPolicyRequestT = Model::DeleteIpamPolicyRequest>
  Model::DeleteIpamPolicyOutcomeCallable DeleteIpamPolicyCallable(const DeleteIpamPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamPolicy, request);
  }
 
  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);
  }
 
  virtual Model::DeleteIpamPoolOutcome DeleteIpamPool(const Model::DeleteIpamPoolRequest& request) const;
 
  template <typename DeleteIpamPoolRequestT = Model::DeleteIpamPoolRequest>
  Model::DeleteIpamPoolOutcomeCallable DeleteIpamPoolCallable(const DeleteIpamPoolRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamPool, request);
  }
 
  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);
  }
 
  virtual Model::DeleteIpamPrefixListResolverOutcome DeleteIpamPrefixListResolver(
      const Model::DeleteIpamPrefixListResolverRequest& request) const;
 
  template <typename DeleteIpamPrefixListResolverRequestT = Model::DeleteIpamPrefixListResolverRequest>
  Model::DeleteIpamPrefixListResolverOutcomeCallable DeleteIpamPrefixListResolverCallable(
      const DeleteIpamPrefixListResolverRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamPrefixListResolver, request);
  }
 
  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);
  }
 
  virtual Model::DeleteIpamPrefixListResolverTargetOutcome DeleteIpamPrefixListResolverTarget(
      const Model::DeleteIpamPrefixListResolverTargetRequest& request) const;
 
  template <typename DeleteIpamPrefixListResolverTargetRequestT = Model::DeleteIpamPrefixListResolverTargetRequest>
  Model::DeleteIpamPrefixListResolverTargetOutcomeCallable DeleteIpamPrefixListResolverTargetCallable(
      const DeleteIpamPrefixListResolverTargetRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamPrefixListResolverTarget, request);
  }
 
  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);
  }
 
  virtual Model::DeleteIpamResourceDiscoveryOutcome DeleteIpamResourceDiscovery(
      const Model::DeleteIpamResourceDiscoveryRequest& request) const;
 
  template <typename DeleteIpamResourceDiscoveryRequestT = Model::DeleteIpamResourceDiscoveryRequest>
  Model::DeleteIpamResourceDiscoveryOutcomeCallable DeleteIpamResourceDiscoveryCallable(
      const DeleteIpamResourceDiscoveryRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamResourceDiscovery, request);
  }
 
  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);
  }
 
  virtual Model::DeleteIpamScopeOutcome DeleteIpamScope(const Model::DeleteIpamScopeRequest& request) const;
 
  template <typename DeleteIpamScopeRequestT = Model::DeleteIpamScopeRequest>
  Model::DeleteIpamScopeOutcomeCallable DeleteIpamScopeCallable(const DeleteIpamScopeRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteIpamScope, request);
  }
 
  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);
  }
 
  virtual Model::DeleteKeyPairOutcome DeleteKeyPair(const Model::DeleteKeyPairRequest& request = {}) const;
 
  template <typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
  Model::DeleteKeyPairOutcomeCallable DeleteKeyPairCallable(const DeleteKeyPairRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DeleteKeyPair, request);
  }
 
  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);
  }
 
  virtual Model::DeleteLaunchTemplateOutcome DeleteLaunchTemplate(const Model::DeleteLaunchTemplateRequest& request = {}) const;
 
  template <typename DeleteLaunchTemplateRequestT = Model::DeleteLaunchTemplateRequest>
  Model::DeleteLaunchTemplateOutcomeCallable DeleteLaunchTemplateCallable(const DeleteLaunchTemplateRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DeleteLaunchTemplate, request);
  }
 
  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);
  }
 
  virtual Model::DeleteLaunchTemplateVersionsOutcome DeleteLaunchTemplateVersions(
      const Model::DeleteLaunchTemplateVersionsRequest& request) const;
 
  template <typename DeleteLaunchTemplateVersionsRequestT = Model::DeleteLaunchTemplateVersionsRequest>
  Model::DeleteLaunchTemplateVersionsOutcomeCallable DeleteLaunchTemplateVersionsCallable(
      const DeleteLaunchTemplateVersionsRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteLaunchTemplateVersions, request);
  }
 
  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);
  }
 
  virtual Model::DeleteLocalGatewayRouteOutcome DeleteLocalGatewayRoute(const Model::DeleteLocalGatewayRouteRequest& request) const;
 
  template <typename DeleteLocalGatewayRouteRequestT = Model::DeleteLocalGatewayRouteRequest>
  Model::DeleteLocalGatewayRouteOutcomeCallable DeleteLocalGatewayRouteCallable(const DeleteLocalGatewayRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteLocalGatewayRoute, request);
  }
 
  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);
  }
 
  virtual Model::DeleteLocalGatewayRouteTableOutcome DeleteLocalGatewayRouteTable(
      const Model::DeleteLocalGatewayRouteTableRequest& request) const;
 
  template <typename DeleteLocalGatewayRouteTableRequestT = Model::DeleteLocalGatewayRouteTableRequest>
  Model::DeleteLocalGatewayRouteTableOutcomeCallable DeleteLocalGatewayRouteTableCallable(
      const DeleteLocalGatewayRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteLocalGatewayRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutcome
  DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(
      const Model::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest& request) const;
 
  template <typename DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT =
                Model::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest>
  Model::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutcomeCallable
  DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationCallable(
      const DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation, request);
  }
 
  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);
  }
 
  virtual Model::DeleteLocalGatewayRouteTableVpcAssociationOutcome DeleteLocalGatewayRouteTableVpcAssociation(
      const Model::DeleteLocalGatewayRouteTableVpcAssociationRequest& request) const;
 
  template <typename DeleteLocalGatewayRouteTableVpcAssociationRequestT = Model::DeleteLocalGatewayRouteTableVpcAssociationRequest>
  Model::DeleteLocalGatewayRouteTableVpcAssociationOutcomeCallable DeleteLocalGatewayRouteTableVpcAssociationCallable(
      const DeleteLocalGatewayRouteTableVpcAssociationRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteLocalGatewayRouteTableVpcAssociation, request);
  }
 
  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);
  }
 
  virtual Model::DeleteLocalGatewayVirtualInterfaceOutcome DeleteLocalGatewayVirtualInterface(
      const Model::DeleteLocalGatewayVirtualInterfaceRequest& request) const;
 
  template <typename DeleteLocalGatewayVirtualInterfaceRequestT = Model::DeleteLocalGatewayVirtualInterfaceRequest>
  Model::DeleteLocalGatewayVirtualInterfaceOutcomeCallable DeleteLocalGatewayVirtualInterfaceCallable(
      const DeleteLocalGatewayVirtualInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteLocalGatewayVirtualInterface, request);
  }
 
  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);
  }
 
  virtual Model::DeleteLocalGatewayVirtualInterfaceGroupOutcome DeleteLocalGatewayVirtualInterfaceGroup(
      const Model::DeleteLocalGatewayVirtualInterfaceGroupRequest& request) const;
 
  template <typename DeleteLocalGatewayVirtualInterfaceGroupRequestT = Model::DeleteLocalGatewayVirtualInterfaceGroupRequest>
  Model::DeleteLocalGatewayVirtualInterfaceGroupOutcomeCallable DeleteLocalGatewayVirtualInterfaceGroupCallable(
      const DeleteLocalGatewayVirtualInterfaceGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteLocalGatewayVirtualInterfaceGroup, request);
  }
 
  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);
  }
 
  virtual Model::DeleteManagedPrefixListOutcome DeleteManagedPrefixList(const Model::DeleteManagedPrefixListRequest& request) const;
 
  template <typename DeleteManagedPrefixListRequestT = Model::DeleteManagedPrefixListRequest>
  Model::DeleteManagedPrefixListOutcomeCallable DeleteManagedPrefixListCallable(const DeleteManagedPrefixListRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteManagedPrefixList, request);
  }
 
  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);
  }
 
  virtual Model::DeleteNatGatewayOutcome DeleteNatGateway(const Model::DeleteNatGatewayRequest& request) const;
 
  template <typename DeleteNatGatewayRequestT = Model::DeleteNatGatewayRequest>
  Model::DeleteNatGatewayOutcomeCallable DeleteNatGatewayCallable(const DeleteNatGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteNatGateway, request);
  }
 
  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);
  }
 
  virtual Model::DeleteNetworkAclOutcome DeleteNetworkAcl(const Model::DeleteNetworkAclRequest& request) const;
 
  template <typename DeleteNetworkAclRequestT = Model::DeleteNetworkAclRequest>
  Model::DeleteNetworkAclOutcomeCallable DeleteNetworkAclCallable(const DeleteNetworkAclRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteNetworkAcl, request);
  }
 
  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);
  }
 
  virtual Model::DeleteNetworkAclEntryOutcome DeleteNetworkAclEntry(const Model::DeleteNetworkAclEntryRequest& request) const;
 
  template <typename DeleteNetworkAclEntryRequestT = Model::DeleteNetworkAclEntryRequest>
  Model::DeleteNetworkAclEntryOutcomeCallable DeleteNetworkAclEntryCallable(const DeleteNetworkAclEntryRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteNetworkAclEntry, request);
  }
 
  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);
  }
 
  virtual Model::DeleteNetworkInsightsAccessScopeOutcome DeleteNetworkInsightsAccessScope(
      const Model::DeleteNetworkInsightsAccessScopeRequest& request) const;
 
  template <typename DeleteNetworkInsightsAccessScopeRequestT = Model::DeleteNetworkInsightsAccessScopeRequest>
  Model::DeleteNetworkInsightsAccessScopeOutcomeCallable DeleteNetworkInsightsAccessScopeCallable(
      const DeleteNetworkInsightsAccessScopeRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteNetworkInsightsAccessScope, request);
  }
 
  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);
  }
 
  virtual Model::DeleteNetworkInsightsAccessScopeAnalysisOutcome DeleteNetworkInsightsAccessScopeAnalysis(
      const Model::DeleteNetworkInsightsAccessScopeAnalysisRequest& request) const;
 
  template <typename DeleteNetworkInsightsAccessScopeAnalysisRequestT = Model::DeleteNetworkInsightsAccessScopeAnalysisRequest>
  Model::DeleteNetworkInsightsAccessScopeAnalysisOutcomeCallable DeleteNetworkInsightsAccessScopeAnalysisCallable(
      const DeleteNetworkInsightsAccessScopeAnalysisRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteNetworkInsightsAccessScopeAnalysis, request);
  }
 
  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);
  }
 
  virtual Model::DeleteNetworkInsightsAnalysisOutcome DeleteNetworkInsightsAnalysis(
      const Model::DeleteNetworkInsightsAnalysisRequest& request) const;
 
  template <typename DeleteNetworkInsightsAnalysisRequestT = Model::DeleteNetworkInsightsAnalysisRequest>
  Model::DeleteNetworkInsightsAnalysisOutcomeCallable DeleteNetworkInsightsAnalysisCallable(
      const DeleteNetworkInsightsAnalysisRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteNetworkInsightsAnalysis, request);
  }
 
  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);
  }
 
  virtual Model::DeleteNetworkInsightsPathOutcome DeleteNetworkInsightsPath(const Model::DeleteNetworkInsightsPathRequest& request) const;
 
  template <typename DeleteNetworkInsightsPathRequestT = Model::DeleteNetworkInsightsPathRequest>
  Model::DeleteNetworkInsightsPathOutcomeCallable DeleteNetworkInsightsPathCallable(
      const DeleteNetworkInsightsPathRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteNetworkInsightsPath, request);
  }
 
  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);
  }
 
  virtual Model::DeleteNetworkInterfaceOutcome DeleteNetworkInterface(const Model::DeleteNetworkInterfaceRequest& request) const;
 
  template <typename DeleteNetworkInterfaceRequestT = Model::DeleteNetworkInterfaceRequest>
  Model::DeleteNetworkInterfaceOutcomeCallable DeleteNetworkInterfaceCallable(const DeleteNetworkInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteNetworkInterface, request);
  }
 
  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);
  }
 
  virtual Model::DeleteNetworkInterfacePermissionOutcome DeleteNetworkInterfacePermission(
      const Model::DeleteNetworkInterfacePermissionRequest& request) const;
 
  template <typename DeleteNetworkInterfacePermissionRequestT = Model::DeleteNetworkInterfacePermissionRequest>
  Model::DeleteNetworkInterfacePermissionOutcomeCallable DeleteNetworkInterfacePermissionCallable(
      const DeleteNetworkInterfacePermissionRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteNetworkInterfacePermission, request);
  }
 
  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);
  }
 
  virtual Model::DeletePlacementGroupOutcome DeletePlacementGroup(const Model::DeletePlacementGroupRequest& request) const;
 
  template <typename DeletePlacementGroupRequestT = Model::DeletePlacementGroupRequest>
  Model::DeletePlacementGroupOutcomeCallable DeletePlacementGroupCallable(const DeletePlacementGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::DeletePlacementGroup, request);
  }
 
  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);
  }
 
  virtual Model::DeletePublicIpv4PoolOutcome DeletePublicIpv4Pool(const Model::DeletePublicIpv4PoolRequest& request) const;
 
  template <typename DeletePublicIpv4PoolRequestT = Model::DeletePublicIpv4PoolRequest>
  Model::DeletePublicIpv4PoolOutcomeCallable DeletePublicIpv4PoolCallable(const DeletePublicIpv4PoolRequestT& request) const {
    return SubmitCallable(&EC2Client::DeletePublicIpv4Pool, request);
  }
 
  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);
  }
 
  virtual Model::DeleteQueuedReservedInstancesOutcome DeleteQueuedReservedInstances(
      const Model::DeleteQueuedReservedInstancesRequest& request) const;
 
  template <typename DeleteQueuedReservedInstancesRequestT = Model::DeleteQueuedReservedInstancesRequest>
  Model::DeleteQueuedReservedInstancesOutcomeCallable DeleteQueuedReservedInstancesCallable(
      const DeleteQueuedReservedInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteQueuedReservedInstances, request);
  }
 
  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);
  }
 
  virtual Model::DeleteRouteOutcome DeleteRoute(const Model::DeleteRouteRequest& request) const;
 
  template <typename DeleteRouteRequestT = Model::DeleteRouteRequest>
  Model::DeleteRouteOutcomeCallable DeleteRouteCallable(const DeleteRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteRoute, request);
  }
 
  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);
  }
 
  virtual Model::DeleteRouteServerOutcome DeleteRouteServer(const Model::DeleteRouteServerRequest& request) const;
 
  template <typename DeleteRouteServerRequestT = Model::DeleteRouteServerRequest>
  Model::DeleteRouteServerOutcomeCallable DeleteRouteServerCallable(const DeleteRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteRouteServer, request);
  }
 
  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);
  }
 
  virtual Model::DeleteRouteServerEndpointOutcome DeleteRouteServerEndpoint(const Model::DeleteRouteServerEndpointRequest& request) const;
 
  template <typename DeleteRouteServerEndpointRequestT = Model::DeleteRouteServerEndpointRequest>
  Model::DeleteRouteServerEndpointOutcomeCallable DeleteRouteServerEndpointCallable(
      const DeleteRouteServerEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteRouteServerEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::DeleteRouteServerPeerOutcome DeleteRouteServerPeer(const Model::DeleteRouteServerPeerRequest& request) const;
 
  template <typename DeleteRouteServerPeerRequestT = Model::DeleteRouteServerPeerRequest>
  Model::DeleteRouteServerPeerOutcomeCallable DeleteRouteServerPeerCallable(const DeleteRouteServerPeerRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteRouteServerPeer, request);
  }
 
  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);
  }
 
  virtual Model::DeleteRouteTableOutcome DeleteRouteTable(const Model::DeleteRouteTableRequest& request) const;
 
  template <typename DeleteRouteTableRequestT = Model::DeleteRouteTableRequest>
  Model::DeleteRouteTableOutcomeCallable DeleteRouteTableCallable(const DeleteRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::DeleteSecondaryNetworkOutcome DeleteSecondaryNetwork(const Model::DeleteSecondaryNetworkRequest& request) const;
 
  template <typename DeleteSecondaryNetworkRequestT = Model::DeleteSecondaryNetworkRequest>
  Model::DeleteSecondaryNetworkOutcomeCallable DeleteSecondaryNetworkCallable(const DeleteSecondaryNetworkRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteSecondaryNetwork, request);
  }
 
  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);
  }
 
  virtual Model::DeleteSecondarySubnetOutcome DeleteSecondarySubnet(const Model::DeleteSecondarySubnetRequest& request) const;
 
  template <typename DeleteSecondarySubnetRequestT = Model::DeleteSecondarySubnetRequest>
  Model::DeleteSecondarySubnetOutcomeCallable DeleteSecondarySubnetCallable(const DeleteSecondarySubnetRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteSecondarySubnet, request);
  }
 
  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);
  }
 
  virtual Model::DeleteSecurityGroupOutcome DeleteSecurityGroup(const Model::DeleteSecurityGroupRequest& request = {}) const;
 
  template <typename DeleteSecurityGroupRequestT = Model::DeleteSecurityGroupRequest>
  Model::DeleteSecurityGroupOutcomeCallable DeleteSecurityGroupCallable(const DeleteSecurityGroupRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DeleteSecurityGroup, request);
  }
 
  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);
  }
 
  virtual Model::DeleteSnapshotOutcome DeleteSnapshot(const Model::DeleteSnapshotRequest& request) const;
 
  template <typename DeleteSnapshotRequestT = Model::DeleteSnapshotRequest>
  Model::DeleteSnapshotOutcomeCallable DeleteSnapshotCallable(const DeleteSnapshotRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteSnapshot, request);
  }
 
  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);
  }
 
  virtual Model::DeleteSpotDatafeedSubscriptionOutcome DeleteSpotDatafeedSubscription(
      const Model::DeleteSpotDatafeedSubscriptionRequest& request = {}) const;
 
  template <typename DeleteSpotDatafeedSubscriptionRequestT = Model::DeleteSpotDatafeedSubscriptionRequest>
  Model::DeleteSpotDatafeedSubscriptionOutcomeCallable DeleteSpotDatafeedSubscriptionCallable(
      const DeleteSpotDatafeedSubscriptionRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DeleteSpotDatafeedSubscription, request);
  }
 
  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);
  }
 
  virtual Model::DeleteSubnetOutcome DeleteSubnet(const Model::DeleteSubnetRequest& request) const;
 
  template <typename DeleteSubnetRequestT = Model::DeleteSubnetRequest>
  Model::DeleteSubnetOutcomeCallable DeleteSubnetCallable(const DeleteSubnetRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteSubnet, request);
  }
 
  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);
  }
 
  virtual Model::DeleteSubnetCidrReservationOutcome DeleteSubnetCidrReservation(
      const Model::DeleteSubnetCidrReservationRequest& request) const;
 
  template <typename DeleteSubnetCidrReservationRequestT = Model::DeleteSubnetCidrReservationRequest>
  Model::DeleteSubnetCidrReservationOutcomeCallable DeleteSubnetCidrReservationCallable(
      const DeleteSubnetCidrReservationRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteSubnetCidrReservation, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const;
 
  template <typename DeleteTagsRequestT = Model::DeleteTagsRequest>
  Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTags, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTrafficMirrorFilterOutcome DeleteTrafficMirrorFilter(const Model::DeleteTrafficMirrorFilterRequest& request) const;
 
  template <typename DeleteTrafficMirrorFilterRequestT = Model::DeleteTrafficMirrorFilterRequest>
  Model::DeleteTrafficMirrorFilterOutcomeCallable DeleteTrafficMirrorFilterCallable(
      const DeleteTrafficMirrorFilterRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTrafficMirrorFilter, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTrafficMirrorFilterRuleOutcome DeleteTrafficMirrorFilterRule(
      const Model::DeleteTrafficMirrorFilterRuleRequest& request) const;
 
  template <typename DeleteTrafficMirrorFilterRuleRequestT = Model::DeleteTrafficMirrorFilterRuleRequest>
  Model::DeleteTrafficMirrorFilterRuleOutcomeCallable DeleteTrafficMirrorFilterRuleCallable(
      const DeleteTrafficMirrorFilterRuleRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTrafficMirrorFilterRule, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTrafficMirrorSessionOutcome DeleteTrafficMirrorSession(
      const Model::DeleteTrafficMirrorSessionRequest& request) const;
 
  template <typename DeleteTrafficMirrorSessionRequestT = Model::DeleteTrafficMirrorSessionRequest>
  Model::DeleteTrafficMirrorSessionOutcomeCallable DeleteTrafficMirrorSessionCallable(
      const DeleteTrafficMirrorSessionRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTrafficMirrorSession, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTrafficMirrorTargetOutcome DeleteTrafficMirrorTarget(const Model::DeleteTrafficMirrorTargetRequest& request) const;
 
  template <typename DeleteTrafficMirrorTargetRequestT = Model::DeleteTrafficMirrorTargetRequest>
  Model::DeleteTrafficMirrorTargetOutcomeCallable DeleteTrafficMirrorTargetCallable(
      const DeleteTrafficMirrorTargetRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTrafficMirrorTarget, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayOutcome DeleteTransitGateway(const Model::DeleteTransitGatewayRequest& request) const;
 
  template <typename DeleteTransitGatewayRequestT = Model::DeleteTransitGatewayRequest>
  Model::DeleteTransitGatewayOutcomeCallable DeleteTransitGatewayCallable(const DeleteTransitGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGateway, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayClientVpnAttachmentOutcome DeleteTransitGatewayClientVpnAttachment(
      const Model::DeleteTransitGatewayClientVpnAttachmentRequest& request) const;
 
  template <typename DeleteTransitGatewayClientVpnAttachmentRequestT = Model::DeleteTransitGatewayClientVpnAttachmentRequest>
  Model::DeleteTransitGatewayClientVpnAttachmentOutcomeCallable DeleteTransitGatewayClientVpnAttachmentCallable(
      const DeleteTransitGatewayClientVpnAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayClientVpnAttachment, request);
  }
 
  template <typename DeleteTransitGatewayClientVpnAttachmentRequestT = Model::DeleteTransitGatewayClientVpnAttachmentRequest>
  void DeleteTransitGatewayClientVpnAttachmentAsync(const DeleteTransitGatewayClientVpnAttachmentRequestT& request,
                                                    const DeleteTransitGatewayClientVpnAttachmentResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DeleteTransitGatewayClientVpnAttachment, request, handler, context);
  }
 
  virtual Model::DeleteTransitGatewayConnectOutcome DeleteTransitGatewayConnect(
      const Model::DeleteTransitGatewayConnectRequest& request) const;
 
  template <typename DeleteTransitGatewayConnectRequestT = Model::DeleteTransitGatewayConnectRequest>
  Model::DeleteTransitGatewayConnectOutcomeCallable DeleteTransitGatewayConnectCallable(
      const DeleteTransitGatewayConnectRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayConnect, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayConnectPeerOutcome DeleteTransitGatewayConnectPeer(
      const Model::DeleteTransitGatewayConnectPeerRequest& request) const;
 
  template <typename DeleteTransitGatewayConnectPeerRequestT = Model::DeleteTransitGatewayConnectPeerRequest>
  Model::DeleteTransitGatewayConnectPeerOutcomeCallable DeleteTransitGatewayConnectPeerCallable(
      const DeleteTransitGatewayConnectPeerRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayConnectPeer, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayMeteringPolicyOutcome DeleteTransitGatewayMeteringPolicy(
      const Model::DeleteTransitGatewayMeteringPolicyRequest& request) const;
 
  template <typename DeleteTransitGatewayMeteringPolicyRequestT = Model::DeleteTransitGatewayMeteringPolicyRequest>
  Model::DeleteTransitGatewayMeteringPolicyOutcomeCallable DeleteTransitGatewayMeteringPolicyCallable(
      const DeleteTransitGatewayMeteringPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayMeteringPolicy, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayMeteringPolicyEntryOutcome DeleteTransitGatewayMeteringPolicyEntry(
      const Model::DeleteTransitGatewayMeteringPolicyEntryRequest& request) const;
 
  template <typename DeleteTransitGatewayMeteringPolicyEntryRequestT = Model::DeleteTransitGatewayMeteringPolicyEntryRequest>
  Model::DeleteTransitGatewayMeteringPolicyEntryOutcomeCallable DeleteTransitGatewayMeteringPolicyEntryCallable(
      const DeleteTransitGatewayMeteringPolicyEntryRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayMeteringPolicyEntry, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayMulticastDomainOutcome DeleteTransitGatewayMulticastDomain(
      const Model::DeleteTransitGatewayMulticastDomainRequest& request) const;
 
  template <typename DeleteTransitGatewayMulticastDomainRequestT = Model::DeleteTransitGatewayMulticastDomainRequest>
  Model::DeleteTransitGatewayMulticastDomainOutcomeCallable DeleteTransitGatewayMulticastDomainCallable(
      const DeleteTransitGatewayMulticastDomainRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayMulticastDomain, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayPeeringAttachmentOutcome DeleteTransitGatewayPeeringAttachment(
      const Model::DeleteTransitGatewayPeeringAttachmentRequest& request) const;
 
  template <typename DeleteTransitGatewayPeeringAttachmentRequestT = Model::DeleteTransitGatewayPeeringAttachmentRequest>
  Model::DeleteTransitGatewayPeeringAttachmentOutcomeCallable DeleteTransitGatewayPeeringAttachmentCallable(
      const DeleteTransitGatewayPeeringAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayPeeringAttachment, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayPolicyTableOutcome DeleteTransitGatewayPolicyTable(
      const Model::DeleteTransitGatewayPolicyTableRequest& request) const;
 
  template <typename DeleteTransitGatewayPolicyTableRequestT = Model::DeleteTransitGatewayPolicyTableRequest>
  Model::DeleteTransitGatewayPolicyTableOutcomeCallable DeleteTransitGatewayPolicyTableCallable(
      const DeleteTransitGatewayPolicyTableRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayPolicyTable, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayPrefixListReferenceOutcome DeleteTransitGatewayPrefixListReference(
      const Model::DeleteTransitGatewayPrefixListReferenceRequest& request) const;
 
  template <typename DeleteTransitGatewayPrefixListReferenceRequestT = Model::DeleteTransitGatewayPrefixListReferenceRequest>
  Model::DeleteTransitGatewayPrefixListReferenceOutcomeCallable DeleteTransitGatewayPrefixListReferenceCallable(
      const DeleteTransitGatewayPrefixListReferenceRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayPrefixListReference, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayRouteOutcome DeleteTransitGatewayRoute(const Model::DeleteTransitGatewayRouteRequest& request) const;
 
  template <typename DeleteTransitGatewayRouteRequestT = Model::DeleteTransitGatewayRouteRequest>
  Model::DeleteTransitGatewayRouteOutcomeCallable DeleteTransitGatewayRouteCallable(
      const DeleteTransitGatewayRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayRoute, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayRouteTableOutcome DeleteTransitGatewayRouteTable(
      const Model::DeleteTransitGatewayRouteTableRequest& request) const;
 
  template <typename DeleteTransitGatewayRouteTableRequestT = Model::DeleteTransitGatewayRouteTableRequest>
  Model::DeleteTransitGatewayRouteTableOutcomeCallable DeleteTransitGatewayRouteTableCallable(
      const DeleteTransitGatewayRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayRouteTableAnnouncementOutcome DeleteTransitGatewayRouteTableAnnouncement(
      const Model::DeleteTransitGatewayRouteTableAnnouncementRequest& request) const;
 
  template <typename DeleteTransitGatewayRouteTableAnnouncementRequestT = Model::DeleteTransitGatewayRouteTableAnnouncementRequest>
  Model::DeleteTransitGatewayRouteTableAnnouncementOutcomeCallable DeleteTransitGatewayRouteTableAnnouncementCallable(
      const DeleteTransitGatewayRouteTableAnnouncementRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayRouteTableAnnouncement, request);
  }
 
  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);
  }
 
  virtual Model::DeleteTransitGatewayVpcAttachmentOutcome DeleteTransitGatewayVpcAttachment(
      const Model::DeleteTransitGatewayVpcAttachmentRequest& request) const;
 
  template <typename DeleteTransitGatewayVpcAttachmentRequestT = Model::DeleteTransitGatewayVpcAttachmentRequest>
  Model::DeleteTransitGatewayVpcAttachmentOutcomeCallable DeleteTransitGatewayVpcAttachmentCallable(
      const DeleteTransitGatewayVpcAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteTransitGatewayVpcAttachment, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVerifiedAccessEndpointOutcome DeleteVerifiedAccessEndpoint(
      const Model::DeleteVerifiedAccessEndpointRequest& request) const;
 
  template <typename DeleteVerifiedAccessEndpointRequestT = Model::DeleteVerifiedAccessEndpointRequest>
  Model::DeleteVerifiedAccessEndpointOutcomeCallable DeleteVerifiedAccessEndpointCallable(
      const DeleteVerifiedAccessEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVerifiedAccessEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVerifiedAccessGroupOutcome DeleteVerifiedAccessGroup(const Model::DeleteVerifiedAccessGroupRequest& request) const;
 
  template <typename DeleteVerifiedAccessGroupRequestT = Model::DeleteVerifiedAccessGroupRequest>
  Model::DeleteVerifiedAccessGroupOutcomeCallable DeleteVerifiedAccessGroupCallable(
      const DeleteVerifiedAccessGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVerifiedAccessGroup, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVerifiedAccessInstanceOutcome DeleteVerifiedAccessInstance(
      const Model::DeleteVerifiedAccessInstanceRequest& request) const;
 
  template <typename DeleteVerifiedAccessInstanceRequestT = Model::DeleteVerifiedAccessInstanceRequest>
  Model::DeleteVerifiedAccessInstanceOutcomeCallable DeleteVerifiedAccessInstanceCallable(
      const DeleteVerifiedAccessInstanceRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVerifiedAccessInstance, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVerifiedAccessTrustProviderOutcome DeleteVerifiedAccessTrustProvider(
      const Model::DeleteVerifiedAccessTrustProviderRequest& request) const;
 
  template <typename DeleteVerifiedAccessTrustProviderRequestT = Model::DeleteVerifiedAccessTrustProviderRequest>
  Model::DeleteVerifiedAccessTrustProviderOutcomeCallable DeleteVerifiedAccessTrustProviderCallable(
      const DeleteVerifiedAccessTrustProviderRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVerifiedAccessTrustProvider, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVolumeOutcome DeleteVolume(const Model::DeleteVolumeRequest& request) const;
 
  template <typename DeleteVolumeRequestT = Model::DeleteVolumeRequest>
  Model::DeleteVolumeOutcomeCallable DeleteVolumeCallable(const DeleteVolumeRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVolume, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpcOutcome DeleteVpc(const Model::DeleteVpcRequest& request) const;
 
  template <typename DeleteVpcRequestT = Model::DeleteVpcRequest>
  Model::DeleteVpcOutcomeCallable DeleteVpcCallable(const DeleteVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpc, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpcBlockPublicAccessExclusionOutcome DeleteVpcBlockPublicAccessExclusion(
      const Model::DeleteVpcBlockPublicAccessExclusionRequest& request) const;
 
  template <typename DeleteVpcBlockPublicAccessExclusionRequestT = Model::DeleteVpcBlockPublicAccessExclusionRequest>
  Model::DeleteVpcBlockPublicAccessExclusionOutcomeCallable DeleteVpcBlockPublicAccessExclusionCallable(
      const DeleteVpcBlockPublicAccessExclusionRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpcBlockPublicAccessExclusion, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpcEncryptionControlOutcome DeleteVpcEncryptionControl(
      const Model::DeleteVpcEncryptionControlRequest& request) const;
 
  template <typename DeleteVpcEncryptionControlRequestT = Model::DeleteVpcEncryptionControlRequest>
  Model::DeleteVpcEncryptionControlOutcomeCallable DeleteVpcEncryptionControlCallable(
      const DeleteVpcEncryptionControlRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpcEncryptionControl, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpcEndpointConnectionNotificationsOutcome DeleteVpcEndpointConnectionNotifications(
      const Model::DeleteVpcEndpointConnectionNotificationsRequest& request) const;
 
  template <typename DeleteVpcEndpointConnectionNotificationsRequestT = Model::DeleteVpcEndpointConnectionNotificationsRequest>
  Model::DeleteVpcEndpointConnectionNotificationsOutcomeCallable DeleteVpcEndpointConnectionNotificationsCallable(
      const DeleteVpcEndpointConnectionNotificationsRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpcEndpointConnectionNotifications, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpcEndpointServiceConfigurationsOutcome DeleteVpcEndpointServiceConfigurations(
      const Model::DeleteVpcEndpointServiceConfigurationsRequest& request) const;
 
  template <typename DeleteVpcEndpointServiceConfigurationsRequestT = Model::DeleteVpcEndpointServiceConfigurationsRequest>
  Model::DeleteVpcEndpointServiceConfigurationsOutcomeCallable DeleteVpcEndpointServiceConfigurationsCallable(
      const DeleteVpcEndpointServiceConfigurationsRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpcEndpointServiceConfigurations, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpcEndpointsOutcome DeleteVpcEndpoints(const Model::DeleteVpcEndpointsRequest& request) const;
 
  template <typename DeleteVpcEndpointsRequestT = Model::DeleteVpcEndpointsRequest>
  Model::DeleteVpcEndpointsOutcomeCallable DeleteVpcEndpointsCallable(const DeleteVpcEndpointsRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpcEndpoints, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpcPeeringConnectionOutcome DeleteVpcPeeringConnection(
      const Model::DeleteVpcPeeringConnectionRequest& request) const;
 
  template <typename DeleteVpcPeeringConnectionRequestT = Model::DeleteVpcPeeringConnectionRequest>
  Model::DeleteVpcPeeringConnectionOutcomeCallable DeleteVpcPeeringConnectionCallable(
      const DeleteVpcPeeringConnectionRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpcPeeringConnection, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpnConcentratorOutcome DeleteVpnConcentrator(const Model::DeleteVpnConcentratorRequest& request) const;
 
  template <typename DeleteVpnConcentratorRequestT = Model::DeleteVpnConcentratorRequest>
  Model::DeleteVpnConcentratorOutcomeCallable DeleteVpnConcentratorCallable(const DeleteVpnConcentratorRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpnConcentrator, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpnConnectionOutcome DeleteVpnConnection(const Model::DeleteVpnConnectionRequest& request) const;
 
  template <typename DeleteVpnConnectionRequestT = Model::DeleteVpnConnectionRequest>
  Model::DeleteVpnConnectionOutcomeCallable DeleteVpnConnectionCallable(const DeleteVpnConnectionRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpnConnection, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpnConnectionRouteOutcome DeleteVpnConnectionRoute(const Model::DeleteVpnConnectionRouteRequest& request) const;
 
  template <typename DeleteVpnConnectionRouteRequestT = Model::DeleteVpnConnectionRouteRequest>
  Model::DeleteVpnConnectionRouteOutcomeCallable DeleteVpnConnectionRouteCallable(const DeleteVpnConnectionRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpnConnectionRoute, request);
  }
 
  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);
  }
 
  virtual Model::DeleteVpnGatewayOutcome DeleteVpnGateway(const Model::DeleteVpnGatewayRequest& request) const;
 
  template <typename DeleteVpnGatewayRequestT = Model::DeleteVpnGatewayRequest>
  Model::DeleteVpnGatewayOutcomeCallable DeleteVpnGatewayCallable(const DeleteVpnGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::DeleteVpnGateway, request);
  }
 
  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);
  }
 
  virtual Model::DeprovisionByoipCidrOutcome DeprovisionByoipCidr(const Model::DeprovisionByoipCidrRequest& request) const;
 
  template <typename DeprovisionByoipCidrRequestT = Model::DeprovisionByoipCidrRequest>
  Model::DeprovisionByoipCidrOutcomeCallable DeprovisionByoipCidrCallable(const DeprovisionByoipCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::DeprovisionByoipCidr, request);
  }
 
  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);
  }
 
  virtual Model::DeprovisionIpamByoasnOutcome DeprovisionIpamByoasn(const Model::DeprovisionIpamByoasnRequest& request) const;
 
  template <typename DeprovisionIpamByoasnRequestT = Model::DeprovisionIpamByoasnRequest>
  Model::DeprovisionIpamByoasnOutcomeCallable DeprovisionIpamByoasnCallable(const DeprovisionIpamByoasnRequestT& request) const {
    return SubmitCallable(&EC2Client::DeprovisionIpamByoasn, request);
  }
 
  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);
  }
 
  virtual Model::DeprovisionIpamPoolCidrOutcome DeprovisionIpamPoolCidr(const Model::DeprovisionIpamPoolCidrRequest& request) const;
 
  template <typename DeprovisionIpamPoolCidrRequestT = Model::DeprovisionIpamPoolCidrRequest>
  Model::DeprovisionIpamPoolCidrOutcomeCallable DeprovisionIpamPoolCidrCallable(const DeprovisionIpamPoolCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::DeprovisionIpamPoolCidr, request);
  }
 
  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);
  }
 
  virtual Model::DeprovisionPublicIpv4PoolCidrOutcome DeprovisionPublicIpv4PoolCidr(
      const Model::DeprovisionPublicIpv4PoolCidrRequest& request) const;
 
  template <typename DeprovisionPublicIpv4PoolCidrRequestT = Model::DeprovisionPublicIpv4PoolCidrRequest>
  Model::DeprovisionPublicIpv4PoolCidrOutcomeCallable DeprovisionPublicIpv4PoolCidrCallable(
      const DeprovisionPublicIpv4PoolCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::DeprovisionPublicIpv4PoolCidr, request);
  }
 
  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);
  }
 
  virtual Model::DeregisterImageOutcome DeregisterImage(const Model::DeregisterImageRequest& request) const;
 
  template <typename DeregisterImageRequestT = Model::DeregisterImageRequest>
  Model::DeregisterImageOutcomeCallable DeregisterImageCallable(const DeregisterImageRequestT& request) const {
    return SubmitCallable(&EC2Client::DeregisterImage, request);
  }
 
  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);
  }
 
  virtual Model::DeregisterInstanceEventNotificationAttributesOutcome DeregisterInstanceEventNotificationAttributes(
      const Model::DeregisterInstanceEventNotificationAttributesRequest& request) const;
 
  template <typename DeregisterInstanceEventNotificationAttributesRequestT = Model::DeregisterInstanceEventNotificationAttributesRequest>
  Model::DeregisterInstanceEventNotificationAttributesOutcomeCallable DeregisterInstanceEventNotificationAttributesCallable(
      const DeregisterInstanceEventNotificationAttributesRequestT& request) const {
    return SubmitCallable(&EC2Client::DeregisterInstanceEventNotificationAttributes, request);
  }
 
  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);
  }
 
  virtual Model::DeregisterTransitGatewayMulticastGroupMembersOutcome DeregisterTransitGatewayMulticastGroupMembers(
      const Model::DeregisterTransitGatewayMulticastGroupMembersRequest& request = {}) const;
 
  template <typename DeregisterTransitGatewayMulticastGroupMembersRequestT = Model::DeregisterTransitGatewayMulticastGroupMembersRequest>
  Model::DeregisterTransitGatewayMulticastGroupMembersOutcomeCallable DeregisterTransitGatewayMulticastGroupMembersCallable(
      const DeregisterTransitGatewayMulticastGroupMembersRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DeregisterTransitGatewayMulticastGroupMembers, request);
  }
 
  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);
  }
 
  virtual Model::DeregisterTransitGatewayMulticastGroupSourcesOutcome DeregisterTransitGatewayMulticastGroupSources(
      const Model::DeregisterTransitGatewayMulticastGroupSourcesRequest& request = {}) const;
 
  template <typename DeregisterTransitGatewayMulticastGroupSourcesRequestT = Model::DeregisterTransitGatewayMulticastGroupSourcesRequest>
  Model::DeregisterTransitGatewayMulticastGroupSourcesOutcomeCallable DeregisterTransitGatewayMulticastGroupSourcesCallable(
      const DeregisterTransitGatewayMulticastGroupSourcesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DeregisterTransitGatewayMulticastGroupSources, request);
  }
 
  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);
  }
 
  virtual Model::DescribeAccountAttributesOutcome DescribeAccountAttributes(
      const Model::DescribeAccountAttributesRequest& request = {}) const;
 
  template <typename DescribeAccountAttributesRequestT = Model::DescribeAccountAttributesRequest>
  Model::DescribeAccountAttributesOutcomeCallable DescribeAccountAttributesCallable(
      const DescribeAccountAttributesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeAccountAttributes, request);
  }
 
  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);
  }
 
  virtual Model::DescribeAccountVpcEncryptionControlOutcome DescribeAccountVpcEncryptionControl(
      const Model::DescribeAccountVpcEncryptionControlRequest& request = {}) const;
 
  template <typename DescribeAccountVpcEncryptionControlRequestT = Model::DescribeAccountVpcEncryptionControlRequest>
  Model::DescribeAccountVpcEncryptionControlOutcomeCallable DescribeAccountVpcEncryptionControlCallable(
      const DescribeAccountVpcEncryptionControlRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeAccountVpcEncryptionControl, request);
  }
 
  template <typename DescribeAccountVpcEncryptionControlRequestT = Model::DescribeAccountVpcEncryptionControlRequest>
  void DescribeAccountVpcEncryptionControlAsync(const DescribeAccountVpcEncryptionControlResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const DescribeAccountVpcEncryptionControlRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeAccountVpcEncryptionControl, request, handler, context);
  }
 
  virtual Model::DescribeAddressTransfersOutcome DescribeAddressTransfers(const Model::DescribeAddressTransfersRequest& request = {}) const;
 
  template <typename DescribeAddressTransfersRequestT = Model::DescribeAddressTransfersRequest>
  Model::DescribeAddressTransfersOutcomeCallable DescribeAddressTransfersCallable(
      const DescribeAddressTransfersRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeAddressTransfers, request);
  }
 
  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);
  }
 
  virtual Model::DescribeAddressesOutcome DescribeAddresses(const Model::DescribeAddressesRequest& request = {}) const;
 
  template <typename DescribeAddressesRequestT = Model::DescribeAddressesRequest>
  Model::DescribeAddressesOutcomeCallable DescribeAddressesCallable(const DescribeAddressesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeAddresses, request);
  }
 
  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);
  }
 
  virtual Model::DescribeAddressesAttributeOutcome DescribeAddressesAttribute(
      const Model::DescribeAddressesAttributeRequest& request = {}) const;
 
  template <typename DescribeAddressesAttributeRequestT = Model::DescribeAddressesAttributeRequest>
  Model::DescribeAddressesAttributeOutcomeCallable DescribeAddressesAttributeCallable(
      const DescribeAddressesAttributeRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeAddressesAttribute, request);
  }
 
  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);
  }
 
  virtual Model::DescribeAggregateIdFormatOutcome DescribeAggregateIdFormat(
      const Model::DescribeAggregateIdFormatRequest& request = {}) const;
 
  template <typename DescribeAggregateIdFormatRequestT = Model::DescribeAggregateIdFormatRequest>
  Model::DescribeAggregateIdFormatOutcomeCallable DescribeAggregateIdFormatCallable(
      const DescribeAggregateIdFormatRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeAggregateIdFormat, request);
  }
 
  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);
  }
 
  virtual Model::DescribeAvailabilityZonesOutcome DescribeAvailabilityZones(
      const Model::DescribeAvailabilityZonesRequest& request = {}) const;
 
  template <typename DescribeAvailabilityZonesRequestT = Model::DescribeAvailabilityZonesRequest>
  Model::DescribeAvailabilityZonesOutcomeCallable DescribeAvailabilityZonesCallable(
      const DescribeAvailabilityZonesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeAvailabilityZones, request);
  }
 
  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);
  }
 
  virtual Model::DescribeAwsNetworkPerformanceMetricSubscriptionsOutcome DescribeAwsNetworkPerformanceMetricSubscriptions(
      const Model::DescribeAwsNetworkPerformanceMetricSubscriptionsRequest& request = {}) const;
 
  template <
      typename DescribeAwsNetworkPerformanceMetricSubscriptionsRequestT = Model::DescribeAwsNetworkPerformanceMetricSubscriptionsRequest>
  Model::DescribeAwsNetworkPerformanceMetricSubscriptionsOutcomeCallable DescribeAwsNetworkPerformanceMetricSubscriptionsCallable(
      const DescribeAwsNetworkPerformanceMetricSubscriptionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeAwsNetworkPerformanceMetricSubscriptions, request);
  }
 
  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);
  }
 
  virtual Model::DescribeBundleTasksOutcome DescribeBundleTasks(const Model::DescribeBundleTasksRequest& request = {}) const;
 
  template <typename DescribeBundleTasksRequestT = Model::DescribeBundleTasksRequest>
  Model::DescribeBundleTasksOutcomeCallable DescribeBundleTasksCallable(const DescribeBundleTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeBundleTasks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeByoipCidrsOutcome DescribeByoipCidrs(const Model::DescribeByoipCidrsRequest& request) const;
 
  template <typename DescribeByoipCidrsRequestT = Model::DescribeByoipCidrsRequest>
  Model::DescribeByoipCidrsOutcomeCallable DescribeByoipCidrsCallable(const DescribeByoipCidrsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeByoipCidrs, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityBlockExtensionHistoryOutcome DescribeCapacityBlockExtensionHistory(
      const Model::DescribeCapacityBlockExtensionHistoryRequest& request = {}) const;
 
  template <typename DescribeCapacityBlockExtensionHistoryRequestT = Model::DescribeCapacityBlockExtensionHistoryRequest>
  Model::DescribeCapacityBlockExtensionHistoryOutcomeCallable DescribeCapacityBlockExtensionHistoryCallable(
      const DescribeCapacityBlockExtensionHistoryRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlockExtensionHistory, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityBlockExtensionOfferingsOutcome DescribeCapacityBlockExtensionOfferings(
      const Model::DescribeCapacityBlockExtensionOfferingsRequest& request) const;
 
  template <typename DescribeCapacityBlockExtensionOfferingsRequestT = Model::DescribeCapacityBlockExtensionOfferingsRequest>
  Model::DescribeCapacityBlockExtensionOfferingsOutcomeCallable DescribeCapacityBlockExtensionOfferingsCallable(
      const DescribeCapacityBlockExtensionOfferingsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlockExtensionOfferings, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityBlockOfferingsOutcome DescribeCapacityBlockOfferings(
      const Model::DescribeCapacityBlockOfferingsRequest& request) const;
 
  template <typename DescribeCapacityBlockOfferingsRequestT = Model::DescribeCapacityBlockOfferingsRequest>
  Model::DescribeCapacityBlockOfferingsOutcomeCallable DescribeCapacityBlockOfferingsCallable(
      const DescribeCapacityBlockOfferingsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlockOfferings, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityBlockStatusOutcome DescribeCapacityBlockStatus(
      const Model::DescribeCapacityBlockStatusRequest& request = {}) const;
 
  template <typename DescribeCapacityBlockStatusRequestT = Model::DescribeCapacityBlockStatusRequest>
  Model::DescribeCapacityBlockStatusOutcomeCallable DescribeCapacityBlockStatusCallable(
      const DescribeCapacityBlockStatusRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlockStatus, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityBlocksOutcome DescribeCapacityBlocks(const Model::DescribeCapacityBlocksRequest& request = {}) const;
 
  template <typename DescribeCapacityBlocksRequestT = Model::DescribeCapacityBlocksRequest>
  Model::DescribeCapacityBlocksOutcomeCallable DescribeCapacityBlocksCallable(const DescribeCapacityBlocksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityBlocks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityManagerDataExportsOutcome DescribeCapacityManagerDataExports(
      const Model::DescribeCapacityManagerDataExportsRequest& request = {}) const;
 
  template <typename DescribeCapacityManagerDataExportsRequestT = Model::DescribeCapacityManagerDataExportsRequest>
  Model::DescribeCapacityManagerDataExportsOutcomeCallable DescribeCapacityManagerDataExportsCallable(
      const DescribeCapacityManagerDataExportsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityManagerDataExports, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityReservationBillingRequestsOutcome DescribeCapacityReservationBillingRequests(
      const Model::DescribeCapacityReservationBillingRequestsRequest& request) const;
 
  template <typename DescribeCapacityReservationBillingRequestsRequestT = Model::DescribeCapacityReservationBillingRequestsRequest>
  Model::DescribeCapacityReservationBillingRequestsOutcomeCallable DescribeCapacityReservationBillingRequestsCallable(
      const DescribeCapacityReservationBillingRequestsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeCapacityReservationBillingRequests, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityReservationCancellationQuotesOutcome DescribeCapacityReservationCancellationQuotes(
      const Model::DescribeCapacityReservationCancellationQuotesRequest& request = {}) const;
 
  template <typename DescribeCapacityReservationCancellationQuotesRequestT = Model::DescribeCapacityReservationCancellationQuotesRequest>
  Model::DescribeCapacityReservationCancellationQuotesOutcomeCallable DescribeCapacityReservationCancellationQuotesCallable(
      const DescribeCapacityReservationCancellationQuotesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityReservationCancellationQuotes, request);
  }
 
  template <typename DescribeCapacityReservationCancellationQuotesRequestT = Model::DescribeCapacityReservationCancellationQuotesRequest>
  void DescribeCapacityReservationCancellationQuotesAsync(
      const DescribeCapacityReservationCancellationQuotesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const DescribeCapacityReservationCancellationQuotesRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeCapacityReservationCancellationQuotes, request, handler, context);
  }
 
  virtual Model::DescribeCapacityReservationFleetsOutcome DescribeCapacityReservationFleets(
      const Model::DescribeCapacityReservationFleetsRequest& request = {}) const;
 
  template <typename DescribeCapacityReservationFleetsRequestT = Model::DescribeCapacityReservationFleetsRequest>
  Model::DescribeCapacityReservationFleetsOutcomeCallable DescribeCapacityReservationFleetsCallable(
      const DescribeCapacityReservationFleetsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityReservationFleets, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityReservationTopologyOutcome DescribeCapacityReservationTopology(
      const Model::DescribeCapacityReservationTopologyRequest& request = {}) const;
 
  template <typename DescribeCapacityReservationTopologyRequestT = Model::DescribeCapacityReservationTopologyRequest>
  Model::DescribeCapacityReservationTopologyOutcomeCallable DescribeCapacityReservationTopologyCallable(
      const DescribeCapacityReservationTopologyRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityReservationTopology, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCapacityReservationsOutcome DescribeCapacityReservations(
      const Model::DescribeCapacityReservationsRequest& request = {}) const;
 
  template <typename DescribeCapacityReservationsRequestT = Model::DescribeCapacityReservationsRequest>
  Model::DescribeCapacityReservationsOutcomeCallable DescribeCapacityReservationsCallable(
      const DescribeCapacityReservationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCapacityReservations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCarrierGatewaysOutcome DescribeCarrierGateways(const Model::DescribeCarrierGatewaysRequest& request = {}) const;
 
  template <typename DescribeCarrierGatewaysRequestT = Model::DescribeCarrierGatewaysRequest>
  Model::DescribeCarrierGatewaysOutcomeCallable DescribeCarrierGatewaysCallable(const DescribeCarrierGatewaysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCarrierGateways, request);
  }
 
  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);
  }
 
  virtual Model::DescribeClassicLinkInstancesOutcome DescribeClassicLinkInstances(
      const Model::DescribeClassicLinkInstancesRequest& request = {}) const;
 
  template <typename DescribeClassicLinkInstancesRequestT = Model::DescribeClassicLinkInstancesRequest>
  Model::DescribeClassicLinkInstancesOutcomeCallable DescribeClassicLinkInstancesCallable(
      const DescribeClassicLinkInstancesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeClassicLinkInstances, request);
  }
 
  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);
  }
 
  virtual Model::DescribeClientVpnAuthorizationRulesOutcome DescribeClientVpnAuthorizationRules(
      const Model::DescribeClientVpnAuthorizationRulesRequest& request) const;
 
  template <typename DescribeClientVpnAuthorizationRulesRequestT = Model::DescribeClientVpnAuthorizationRulesRequest>
  Model::DescribeClientVpnAuthorizationRulesOutcomeCallable DescribeClientVpnAuthorizationRulesCallable(
      const DescribeClientVpnAuthorizationRulesRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeClientVpnAuthorizationRules, request);
  }
 
  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);
  }
 
  virtual Model::DescribeClientVpnConnectionsOutcome DescribeClientVpnConnections(
      const Model::DescribeClientVpnConnectionsRequest& request) const;
 
  template <typename DescribeClientVpnConnectionsRequestT = Model::DescribeClientVpnConnectionsRequest>
  Model::DescribeClientVpnConnectionsOutcomeCallable DescribeClientVpnConnectionsCallable(
      const DescribeClientVpnConnectionsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeClientVpnConnections, request);
  }
 
  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);
  }
 
  virtual Model::DescribeClientVpnEndpointsOutcome DescribeClientVpnEndpoints(
      const Model::DescribeClientVpnEndpointsRequest& request = {}) const;
 
  template <typename DescribeClientVpnEndpointsRequestT = Model::DescribeClientVpnEndpointsRequest>
  Model::DescribeClientVpnEndpointsOutcomeCallable DescribeClientVpnEndpointsCallable(
      const DescribeClientVpnEndpointsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeClientVpnEndpoints, request);
  }
 
  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);
  }
 
  virtual Model::DescribeClientVpnRoutesOutcome DescribeClientVpnRoutes(const Model::DescribeClientVpnRoutesRequest& request) const;
 
  template <typename DescribeClientVpnRoutesRequestT = Model::DescribeClientVpnRoutesRequest>
  Model::DescribeClientVpnRoutesOutcomeCallable DescribeClientVpnRoutesCallable(const DescribeClientVpnRoutesRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeClientVpnRoutes, request);
  }
 
  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);
  }
 
  virtual Model::DescribeClientVpnTargetNetworksOutcome DescribeClientVpnTargetNetworks(
      const Model::DescribeClientVpnTargetNetworksRequest& request) const;
 
  template <typename DescribeClientVpnTargetNetworksRequestT = Model::DescribeClientVpnTargetNetworksRequest>
  Model::DescribeClientVpnTargetNetworksOutcomeCallable DescribeClientVpnTargetNetworksCallable(
      const DescribeClientVpnTargetNetworksRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeClientVpnTargetNetworks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCoipPoolsOutcome DescribeCoipPools(const Model::DescribeCoipPoolsRequest& request = {}) const;
 
  template <typename DescribeCoipPoolsRequestT = Model::DescribeCoipPoolsRequest>
  Model::DescribeCoipPoolsOutcomeCallable DescribeCoipPoolsCallable(const DescribeCoipPoolsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCoipPools, request);
  }
 
  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);
  }
 
  virtual Model::DescribeConversionTasksOutcome DescribeConversionTasks(const Model::DescribeConversionTasksRequest& request = {}) const;
 
  template <typename DescribeConversionTasksRequestT = Model::DescribeConversionTasksRequest>
  Model::DescribeConversionTasksOutcomeCallable DescribeConversionTasksCallable(const DescribeConversionTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeConversionTasks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeCustomerGatewaysOutcome DescribeCustomerGateways(const Model::DescribeCustomerGatewaysRequest& request = {}) const;
 
  template <typename DescribeCustomerGatewaysRequestT = Model::DescribeCustomerGatewaysRequest>
  Model::DescribeCustomerGatewaysOutcomeCallable DescribeCustomerGatewaysCallable(
      const DescribeCustomerGatewaysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeCustomerGateways, request);
  }
 
  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);
  }
 
  virtual Model::DescribeDeclarativePoliciesReportsOutcome DescribeDeclarativePoliciesReports(
      const Model::DescribeDeclarativePoliciesReportsRequest& request = {}) const;
 
  template <typename DescribeDeclarativePoliciesReportsRequestT = Model::DescribeDeclarativePoliciesReportsRequest>
  Model::DescribeDeclarativePoliciesReportsOutcomeCallable DescribeDeclarativePoliciesReportsCallable(
      const DescribeDeclarativePoliciesReportsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeDeclarativePoliciesReports, request);
  }
 
  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);
  }
 
  virtual Model::DescribeDhcpOptionsOutcome DescribeDhcpOptions(const Model::DescribeDhcpOptionsRequest& request = {}) const;
 
  template <typename DescribeDhcpOptionsRequestT = Model::DescribeDhcpOptionsRequest>
  Model::DescribeDhcpOptionsOutcomeCallable DescribeDhcpOptionsCallable(const DescribeDhcpOptionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeDhcpOptions, request);
  }
 
  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);
  }
 
  virtual Model::DescribeEgressOnlyInternetGatewaysOutcome DescribeEgressOnlyInternetGateways(
      const Model::DescribeEgressOnlyInternetGatewaysRequest& request = {}) const;
 
  template <typename DescribeEgressOnlyInternetGatewaysRequestT = Model::DescribeEgressOnlyInternetGatewaysRequest>
  Model::DescribeEgressOnlyInternetGatewaysOutcomeCallable DescribeEgressOnlyInternetGatewaysCallable(
      const DescribeEgressOnlyInternetGatewaysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeEgressOnlyInternetGateways, request);
  }
 
  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);
  }
 
  virtual Model::DescribeElasticGpusOutcome DescribeElasticGpus(const Model::DescribeElasticGpusRequest& request = {}) const;
 
  template <typename DescribeElasticGpusRequestT = Model::DescribeElasticGpusRequest>
  Model::DescribeElasticGpusOutcomeCallable DescribeElasticGpusCallable(const DescribeElasticGpusRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeElasticGpus, request);
  }
 
  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);
  }
 
  virtual Model::DescribeExportImageTasksOutcome DescribeExportImageTasks(const Model::DescribeExportImageTasksRequest& request = {}) const;
 
  template <typename DescribeExportImageTasksRequestT = Model::DescribeExportImageTasksRequest>
  Model::DescribeExportImageTasksOutcomeCallable DescribeExportImageTasksCallable(
      const DescribeExportImageTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeExportImageTasks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeExportTasksOutcome DescribeExportTasks(const Model::DescribeExportTasksRequest& request = {}) const;
 
  template <typename DescribeExportTasksRequestT = Model::DescribeExportTasksRequest>
  Model::DescribeExportTasksOutcomeCallable DescribeExportTasksCallable(const DescribeExportTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeExportTasks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeFastLaunchImagesOutcome DescribeFastLaunchImages(const Model::DescribeFastLaunchImagesRequest& request = {}) const;
 
  template <typename DescribeFastLaunchImagesRequestT = Model::DescribeFastLaunchImagesRequest>
  Model::DescribeFastLaunchImagesOutcomeCallable DescribeFastLaunchImagesCallable(
      const DescribeFastLaunchImagesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeFastLaunchImages, request);
  }
 
  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);
  }
 
  virtual Model::DescribeFastSnapshotRestoresOutcome DescribeFastSnapshotRestores(
      const Model::DescribeFastSnapshotRestoresRequest& request = {}) const;
 
  template <typename DescribeFastSnapshotRestoresRequestT = Model::DescribeFastSnapshotRestoresRequest>
  Model::DescribeFastSnapshotRestoresOutcomeCallable DescribeFastSnapshotRestoresCallable(
      const DescribeFastSnapshotRestoresRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeFastSnapshotRestores, request);
  }
 
  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);
  }
 
  virtual Model::DescribeFleetHistoryOutcome DescribeFleetHistory(const Model::DescribeFleetHistoryRequest& request) const;
 
  template <typename DescribeFleetHistoryRequestT = Model::DescribeFleetHistoryRequest>
  Model::DescribeFleetHistoryOutcomeCallable DescribeFleetHistoryCallable(const DescribeFleetHistoryRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeFleetHistory, request);
  }
 
  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);
  }
 
  virtual Model::DescribeFleetInstancesOutcome DescribeFleetInstances(const Model::DescribeFleetInstancesRequest& request) const;
 
  template <typename DescribeFleetInstancesRequestT = Model::DescribeFleetInstancesRequest>
  Model::DescribeFleetInstancesOutcomeCallable DescribeFleetInstancesCallable(const DescribeFleetInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeFleetInstances, request);
  }
 
  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);
  }
 
  virtual Model::DescribeFleetsOutcome DescribeFleets(const Model::DescribeFleetsRequest& request = {}) const;
 
  template <typename DescribeFleetsRequestT = Model::DescribeFleetsRequest>
  Model::DescribeFleetsOutcomeCallable DescribeFleetsCallable(const DescribeFleetsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeFleets, request);
  }
 
  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);
  }
 
  virtual Model::DescribeFlowLogsOutcome DescribeFlowLogs(const Model::DescribeFlowLogsRequest& request = {}) const;
 
  template <typename DescribeFlowLogsRequestT = Model::DescribeFlowLogsRequest>
  Model::DescribeFlowLogsOutcomeCallable DescribeFlowLogsCallable(const DescribeFlowLogsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeFlowLogs, request);
  }
 
  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);
  }
 
  virtual Model::DescribeFpgaImageAttributeOutcome DescribeFpgaImageAttribute(
      const Model::DescribeFpgaImageAttributeRequest& request) const;
 
  template <typename DescribeFpgaImageAttributeRequestT = Model::DescribeFpgaImageAttributeRequest>
  Model::DescribeFpgaImageAttributeOutcomeCallable DescribeFpgaImageAttributeCallable(
      const DescribeFpgaImageAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeFpgaImageAttribute, request);
  }
 
  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);
  }
 
  virtual Model::DescribeFpgaImagesOutcome DescribeFpgaImages(const Model::DescribeFpgaImagesRequest& request = {}) const;
 
  template <typename DescribeFpgaImagesRequestT = Model::DescribeFpgaImagesRequest>
  Model::DescribeFpgaImagesOutcomeCallable DescribeFpgaImagesCallable(const DescribeFpgaImagesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeFpgaImages, request);
  }
 
  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);
  }
 
  virtual Model::DescribeHostReservationOfferingsOutcome DescribeHostReservationOfferings(
      const Model::DescribeHostReservationOfferingsRequest& request = {}) const;
 
  template <typename DescribeHostReservationOfferingsRequestT = Model::DescribeHostReservationOfferingsRequest>
  Model::DescribeHostReservationOfferingsOutcomeCallable DescribeHostReservationOfferingsCallable(
      const DescribeHostReservationOfferingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeHostReservationOfferings, request);
  }
 
  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);
  }
 
  virtual Model::DescribeHostReservationsOutcome DescribeHostReservations(const Model::DescribeHostReservationsRequest& request = {}) const;
 
  template <typename DescribeHostReservationsRequestT = Model::DescribeHostReservationsRequest>
  Model::DescribeHostReservationsOutcomeCallable DescribeHostReservationsCallable(
      const DescribeHostReservationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeHostReservations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeHostsOutcome DescribeHosts(const Model::DescribeHostsRequest& request = {}) const;
 
  template <typename DescribeHostsRequestT = Model::DescribeHostsRequest>
  Model::DescribeHostsOutcomeCallable DescribeHostsCallable(const DescribeHostsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeHosts, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIamInstanceProfileAssociationsOutcome DescribeIamInstanceProfileAssociations(
      const Model::DescribeIamInstanceProfileAssociationsRequest& request = {}) const;
 
  template <typename DescribeIamInstanceProfileAssociationsRequestT = Model::DescribeIamInstanceProfileAssociationsRequest>
  Model::DescribeIamInstanceProfileAssociationsOutcomeCallable DescribeIamInstanceProfileAssociationsCallable(
      const DescribeIamInstanceProfileAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIamInstanceProfileAssociations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIdFormatOutcome DescribeIdFormat(const Model::DescribeIdFormatRequest& request = {}) const;
 
  template <typename DescribeIdFormatRequestT = Model::DescribeIdFormatRequest>
  Model::DescribeIdFormatOutcomeCallable DescribeIdFormatCallable(const DescribeIdFormatRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIdFormat, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIdentityIdFormatOutcome DescribeIdentityIdFormat(const Model::DescribeIdentityIdFormatRequest& request) const;
 
  template <typename DescribeIdentityIdFormatRequestT = Model::DescribeIdentityIdFormatRequest>
  Model::DescribeIdentityIdFormatOutcomeCallable DescribeIdentityIdFormatCallable(const DescribeIdentityIdFormatRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeIdentityIdFormat, request);
  }
 
  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);
  }
 
  virtual Model::DescribeImageAttributeOutcome DescribeImageAttribute(const Model::DescribeImageAttributeRequest& request) const;
 
  template <typename DescribeImageAttributeRequestT = Model::DescribeImageAttributeRequest>
  Model::DescribeImageAttributeOutcomeCallable DescribeImageAttributeCallable(const DescribeImageAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeImageAttribute, request);
  }
 
  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);
  }
 
  virtual Model::DescribeImageReferencesOutcome DescribeImageReferences(const Model::DescribeImageReferencesRequest& request) const;
 
  template <typename DescribeImageReferencesRequestT = Model::DescribeImageReferencesRequest>
  Model::DescribeImageReferencesOutcomeCallable DescribeImageReferencesCallable(const DescribeImageReferencesRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeImageReferences, request);
  }
 
  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);
  }
 
  virtual Model::DescribeImageUsageReportEntriesOutcome DescribeImageUsageReportEntries(
      const Model::DescribeImageUsageReportEntriesRequest& request = {}) const;
 
  template <typename DescribeImageUsageReportEntriesRequestT = Model::DescribeImageUsageReportEntriesRequest>
  Model::DescribeImageUsageReportEntriesOutcomeCallable DescribeImageUsageReportEntriesCallable(
      const DescribeImageUsageReportEntriesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeImageUsageReportEntries, request);
  }
 
  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);
  }
 
  virtual Model::DescribeImageUsageReportsOutcome DescribeImageUsageReports(
      const Model::DescribeImageUsageReportsRequest& request = {}) const;
 
  template <typename DescribeImageUsageReportsRequestT = Model::DescribeImageUsageReportsRequest>
  Model::DescribeImageUsageReportsOutcomeCallable DescribeImageUsageReportsCallable(
      const DescribeImageUsageReportsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeImageUsageReports, request);
  }
 
  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);
  }
 
  virtual Model::DescribeImagesOutcome DescribeImages(const Model::DescribeImagesRequest& request = {}) const;
 
  template <typename DescribeImagesRequestT = Model::DescribeImagesRequest>
  Model::DescribeImagesOutcomeCallable DescribeImagesCallable(const DescribeImagesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeImages, request);
  }
 
  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);
  }
 
  virtual Model::DescribeImportImageTasksOutcome DescribeImportImageTasks(const Model::DescribeImportImageTasksRequest& request = {}) const;
 
  template <typename DescribeImportImageTasksRequestT = Model::DescribeImportImageTasksRequest>
  Model::DescribeImportImageTasksOutcomeCallable DescribeImportImageTasksCallable(
      const DescribeImportImageTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeImportImageTasks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeImportSnapshotTasksOutcome DescribeImportSnapshotTasks(
      const Model::DescribeImportSnapshotTasksRequest& request = {}) const;
 
  template <typename DescribeImportSnapshotTasksRequestT = Model::DescribeImportSnapshotTasksRequest>
  Model::DescribeImportSnapshotTasksOutcomeCallable DescribeImportSnapshotTasksCallable(
      const DescribeImportSnapshotTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeImportSnapshotTasks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceAttributeOutcome DescribeInstanceAttribute(const Model::DescribeInstanceAttributeRequest& request) const;
 
  template <typename DescribeInstanceAttributeRequestT = Model::DescribeInstanceAttributeRequest>
  Model::DescribeInstanceAttributeOutcomeCallable DescribeInstanceAttributeCallable(
      const DescribeInstanceAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeInstanceAttribute, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceConnectEndpointsOutcome DescribeInstanceConnectEndpoints(
      const Model::DescribeInstanceConnectEndpointsRequest& request = {}) const;
 
  template <typename DescribeInstanceConnectEndpointsRequestT = Model::DescribeInstanceConnectEndpointsRequest>
  Model::DescribeInstanceConnectEndpointsOutcomeCallable DescribeInstanceConnectEndpointsCallable(
      const DescribeInstanceConnectEndpointsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceConnectEndpoints, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceCreditSpecificationsOutcome DescribeInstanceCreditSpecifications(
      const Model::DescribeInstanceCreditSpecificationsRequest& request = {}) const;
 
  template <typename DescribeInstanceCreditSpecificationsRequestT = Model::DescribeInstanceCreditSpecificationsRequest>
  Model::DescribeInstanceCreditSpecificationsOutcomeCallable DescribeInstanceCreditSpecificationsCallable(
      const DescribeInstanceCreditSpecificationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceCreditSpecifications, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceEventNotificationAttributesOutcome DescribeInstanceEventNotificationAttributes(
      const Model::DescribeInstanceEventNotificationAttributesRequest& request = {}) const;
 
  template <typename DescribeInstanceEventNotificationAttributesRequestT = Model::DescribeInstanceEventNotificationAttributesRequest>
  Model::DescribeInstanceEventNotificationAttributesOutcomeCallable DescribeInstanceEventNotificationAttributesCallable(
      const DescribeInstanceEventNotificationAttributesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceEventNotificationAttributes, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceEventWindowsOutcome DescribeInstanceEventWindows(
      const Model::DescribeInstanceEventWindowsRequest& request = {}) const;
 
  template <typename DescribeInstanceEventWindowsRequestT = Model::DescribeInstanceEventWindowsRequest>
  Model::DescribeInstanceEventWindowsOutcomeCallable DescribeInstanceEventWindowsCallable(
      const DescribeInstanceEventWindowsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceEventWindows, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceImageMetadataOutcome DescribeInstanceImageMetadata(
      const Model::DescribeInstanceImageMetadataRequest& request = {}) const;
 
  template <typename DescribeInstanceImageMetadataRequestT = Model::DescribeInstanceImageMetadataRequest>
  Model::DescribeInstanceImageMetadataOutcomeCallable DescribeInstanceImageMetadataCallable(
      const DescribeInstanceImageMetadataRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceImageMetadata, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceSqlHaHistoryStatesOutcome DescribeInstanceSqlHaHistoryStates(
      const Model::DescribeInstanceSqlHaHistoryStatesRequest& request = {}) const;
 
  template <typename DescribeInstanceSqlHaHistoryStatesRequestT = Model::DescribeInstanceSqlHaHistoryStatesRequest>
  Model::DescribeInstanceSqlHaHistoryStatesOutcomeCallable DescribeInstanceSqlHaHistoryStatesCallable(
      const DescribeInstanceSqlHaHistoryStatesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceSqlHaHistoryStates, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceSqlHaStatesOutcome DescribeInstanceSqlHaStates(
      const Model::DescribeInstanceSqlHaStatesRequest& request = {}) const;
 
  template <typename DescribeInstanceSqlHaStatesRequestT = Model::DescribeInstanceSqlHaStatesRequest>
  Model::DescribeInstanceSqlHaStatesOutcomeCallable DescribeInstanceSqlHaStatesCallable(
      const DescribeInstanceSqlHaStatesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceSqlHaStates, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceStatusOutcome DescribeInstanceStatus(const Model::DescribeInstanceStatusRequest& request = {}) const;
 
  template <typename DescribeInstanceStatusRequestT = Model::DescribeInstanceStatusRequest>
  Model::DescribeInstanceStatusOutcomeCallable DescribeInstanceStatusCallable(const DescribeInstanceStatusRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceStatus, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceTopologyOutcome DescribeInstanceTopology(const Model::DescribeInstanceTopologyRequest& request = {}) const;
 
  template <typename DescribeInstanceTopologyRequestT = Model::DescribeInstanceTopologyRequest>
  Model::DescribeInstanceTopologyOutcomeCallable DescribeInstanceTopologyCallable(
      const DescribeInstanceTopologyRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceTopology, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceTypeOfferingsOutcome DescribeInstanceTypeOfferings(
      const Model::DescribeInstanceTypeOfferingsRequest& request = {}) const;
 
  template <typename DescribeInstanceTypeOfferingsRequestT = Model::DescribeInstanceTypeOfferingsRequest>
  Model::DescribeInstanceTypeOfferingsOutcomeCallable DescribeInstanceTypeOfferingsCallable(
      const DescribeInstanceTypeOfferingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceTypeOfferings, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstanceTypesOutcome DescribeInstanceTypes(const Model::DescribeInstanceTypesRequest& request = {}) const;
 
  template <typename DescribeInstanceTypesRequestT = Model::DescribeInstanceTypesRequest>
  Model::DescribeInstanceTypesOutcomeCallable DescribeInstanceTypesCallable(const DescribeInstanceTypesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstanceTypes, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInstancesOutcome DescribeInstances(const Model::DescribeInstancesRequest& request = {}) const;
 
  template <typename DescribeInstancesRequestT = Model::DescribeInstancesRequest>
  Model::DescribeInstancesOutcomeCallable DescribeInstancesCallable(const DescribeInstancesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInstances, request);
  }
 
  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);
  }
 
  virtual Model::DescribeInternetGatewaysOutcome DescribeInternetGateways(const Model::DescribeInternetGatewaysRequest& request = {}) const;
 
  template <typename DescribeInternetGatewaysRequestT = Model::DescribeInternetGatewaysRequest>
  Model::DescribeInternetGatewaysOutcomeCallable DescribeInternetGatewaysCallable(
      const DescribeInternetGatewaysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeInternetGateways, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamByoasnOutcome DescribeIpamByoasn(const Model::DescribeIpamByoasnRequest& request = {}) const;
 
  template <typename DescribeIpamByoasnRequestT = Model::DescribeIpamByoasnRequest>
  Model::DescribeIpamByoasnOutcomeCallable DescribeIpamByoasnCallable(const DescribeIpamByoasnRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamByoasn, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamExternalResourceVerificationTokensOutcome DescribeIpamExternalResourceVerificationTokens(
      const Model::DescribeIpamExternalResourceVerificationTokensRequest& request = {}) const;
 
  template <typename DescribeIpamExternalResourceVerificationTokensRequestT = Model::DescribeIpamExternalResourceVerificationTokensRequest>
  Model::DescribeIpamExternalResourceVerificationTokensOutcomeCallable DescribeIpamExternalResourceVerificationTokensCallable(
      const DescribeIpamExternalResourceVerificationTokensRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamExternalResourceVerificationTokens, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamPoliciesOutcome DescribeIpamPolicies(const Model::DescribeIpamPoliciesRequest& request = {}) const;
 
  template <typename DescribeIpamPoliciesRequestT = Model::DescribeIpamPoliciesRequest>
  Model::DescribeIpamPoliciesOutcomeCallable DescribeIpamPoliciesCallable(const DescribeIpamPoliciesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamPolicies, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamPoolAllocationsOutcome DescribeIpamPoolAllocations(
      const Model::DescribeIpamPoolAllocationsRequest& request = {}) const;
 
  template <typename DescribeIpamPoolAllocationsRequestT = Model::DescribeIpamPoolAllocationsRequest>
  Model::DescribeIpamPoolAllocationsOutcomeCallable DescribeIpamPoolAllocationsCallable(
      const DescribeIpamPoolAllocationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamPoolAllocations, request);
  }
 
  template <typename DescribeIpamPoolAllocationsRequestT = Model::DescribeIpamPoolAllocationsRequest>
  void DescribeIpamPoolAllocationsAsync(const DescribeIpamPoolAllocationsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeIpamPoolAllocationsRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::DescribeIpamPoolAllocations, request, handler, context);
  }
 
  virtual Model::DescribeIpamPoolsOutcome DescribeIpamPools(const Model::DescribeIpamPoolsRequest& request = {}) const;
 
  template <typename DescribeIpamPoolsRequestT = Model::DescribeIpamPoolsRequest>
  Model::DescribeIpamPoolsOutcomeCallable DescribeIpamPoolsCallable(const DescribeIpamPoolsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamPools, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamPrefixListResolverTargetsOutcome DescribeIpamPrefixListResolverTargets(
      const Model::DescribeIpamPrefixListResolverTargetsRequest& request = {}) const;
 
  template <typename DescribeIpamPrefixListResolverTargetsRequestT = Model::DescribeIpamPrefixListResolverTargetsRequest>
  Model::DescribeIpamPrefixListResolverTargetsOutcomeCallable DescribeIpamPrefixListResolverTargetsCallable(
      const DescribeIpamPrefixListResolverTargetsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamPrefixListResolverTargets, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamPrefixListResolversOutcome DescribeIpamPrefixListResolvers(
      const Model::DescribeIpamPrefixListResolversRequest& request = {}) const;
 
  template <typename DescribeIpamPrefixListResolversRequestT = Model::DescribeIpamPrefixListResolversRequest>
  Model::DescribeIpamPrefixListResolversOutcomeCallable DescribeIpamPrefixListResolversCallable(
      const DescribeIpamPrefixListResolversRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamPrefixListResolvers, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamResourceDiscoveriesOutcome DescribeIpamResourceDiscoveries(
      const Model::DescribeIpamResourceDiscoveriesRequest& request = {}) const;
 
  template <typename DescribeIpamResourceDiscoveriesRequestT = Model::DescribeIpamResourceDiscoveriesRequest>
  Model::DescribeIpamResourceDiscoveriesOutcomeCallable DescribeIpamResourceDiscoveriesCallable(
      const DescribeIpamResourceDiscoveriesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamResourceDiscoveries, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamResourceDiscoveryAssociationsOutcome DescribeIpamResourceDiscoveryAssociations(
      const Model::DescribeIpamResourceDiscoveryAssociationsRequest& request = {}) const;
 
  template <typename DescribeIpamResourceDiscoveryAssociationsRequestT = Model::DescribeIpamResourceDiscoveryAssociationsRequest>
  Model::DescribeIpamResourceDiscoveryAssociationsOutcomeCallable DescribeIpamResourceDiscoveryAssociationsCallable(
      const DescribeIpamResourceDiscoveryAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamResourceDiscoveryAssociations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamScopesOutcome DescribeIpamScopes(const Model::DescribeIpamScopesRequest& request = {}) const;
 
  template <typename DescribeIpamScopesRequestT = Model::DescribeIpamScopesRequest>
  Model::DescribeIpamScopesOutcomeCallable DescribeIpamScopesCallable(const DescribeIpamScopesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpamScopes, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpamsOutcome DescribeIpams(const Model::DescribeIpamsRequest& request = {}) const;
 
  template <typename DescribeIpamsRequestT = Model::DescribeIpamsRequest>
  Model::DescribeIpamsOutcomeCallable DescribeIpamsCallable(const DescribeIpamsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpams, request);
  }
 
  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);
  }
 
  virtual Model::DescribeIpv6PoolsOutcome DescribeIpv6Pools(const Model::DescribeIpv6PoolsRequest& request = {}) const;
 
  template <typename DescribeIpv6PoolsRequestT = Model::DescribeIpv6PoolsRequest>
  Model::DescribeIpv6PoolsOutcomeCallable DescribeIpv6PoolsCallable(const DescribeIpv6PoolsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeIpv6Pools, request);
  }
 
  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);
  }
 
  virtual Model::DescribeKeyPairsOutcome DescribeKeyPairs(const Model::DescribeKeyPairsRequest& request = {}) const;
 
  template <typename DescribeKeyPairsRequestT = Model::DescribeKeyPairsRequest>
  Model::DescribeKeyPairsOutcomeCallable DescribeKeyPairsCallable(const DescribeKeyPairsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeKeyPairs, request);
  }
 
  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);
  }
 
  virtual Model::DescribeLaunchTemplateVersionsOutcome DescribeLaunchTemplateVersions(
      const Model::DescribeLaunchTemplateVersionsRequest& request = {}) const;
 
  template <typename DescribeLaunchTemplateVersionsRequestT = Model::DescribeLaunchTemplateVersionsRequest>
  Model::DescribeLaunchTemplateVersionsOutcomeCallable DescribeLaunchTemplateVersionsCallable(
      const DescribeLaunchTemplateVersionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLaunchTemplateVersions, request);
  }
 
  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);
  }
 
  virtual Model::DescribeLaunchTemplatesOutcome DescribeLaunchTemplates(const Model::DescribeLaunchTemplatesRequest& request = {}) const;
 
  template <typename DescribeLaunchTemplatesRequestT = Model::DescribeLaunchTemplatesRequest>
  Model::DescribeLaunchTemplatesOutcomeCallable DescribeLaunchTemplatesCallable(const DescribeLaunchTemplatesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLaunchTemplates, request);
  }
 
  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);
  }
 
  virtual Model::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutcome
  DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(
      const Model::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest& request = {}) const;
 
  template <typename DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequestT =
                Model::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest>
  Model::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutcomeCallable
  DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsCallable(
      const DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeLocalGatewayRouteTableVpcAssociationsOutcome DescribeLocalGatewayRouteTableVpcAssociations(
      const Model::DescribeLocalGatewayRouteTableVpcAssociationsRequest& request = {}) const;
 
  template <typename DescribeLocalGatewayRouteTableVpcAssociationsRequestT = Model::DescribeLocalGatewayRouteTableVpcAssociationsRequest>
  Model::DescribeLocalGatewayRouteTableVpcAssociationsOutcomeCallable DescribeLocalGatewayRouteTableVpcAssociationsCallable(
      const DescribeLocalGatewayRouteTableVpcAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLocalGatewayRouteTableVpcAssociations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeLocalGatewayRouteTablesOutcome DescribeLocalGatewayRouteTables(
      const Model::DescribeLocalGatewayRouteTablesRequest& request = {}) const;
 
  template <typename DescribeLocalGatewayRouteTablesRequestT = Model::DescribeLocalGatewayRouteTablesRequest>
  Model::DescribeLocalGatewayRouteTablesOutcomeCallable DescribeLocalGatewayRouteTablesCallable(
      const DescribeLocalGatewayRouteTablesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLocalGatewayRouteTables, request);
  }
 
  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);
  }
 
  virtual Model::DescribeLocalGatewayVirtualInterfaceGroupsOutcome DescribeLocalGatewayVirtualInterfaceGroups(
      const Model::DescribeLocalGatewayVirtualInterfaceGroupsRequest& request = {}) const;
 
  template <typename DescribeLocalGatewayVirtualInterfaceGroupsRequestT = Model::DescribeLocalGatewayVirtualInterfaceGroupsRequest>
  Model::DescribeLocalGatewayVirtualInterfaceGroupsOutcomeCallable DescribeLocalGatewayVirtualInterfaceGroupsCallable(
      const DescribeLocalGatewayVirtualInterfaceGroupsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLocalGatewayVirtualInterfaceGroups, request);
  }
 
  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);
  }
 
  virtual Model::DescribeLocalGatewayVirtualInterfacesOutcome DescribeLocalGatewayVirtualInterfaces(
      const Model::DescribeLocalGatewayVirtualInterfacesRequest& request = {}) const;
 
  template <typename DescribeLocalGatewayVirtualInterfacesRequestT = Model::DescribeLocalGatewayVirtualInterfacesRequest>
  Model::DescribeLocalGatewayVirtualInterfacesOutcomeCallable DescribeLocalGatewayVirtualInterfacesCallable(
      const DescribeLocalGatewayVirtualInterfacesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLocalGatewayVirtualInterfaces, request);
  }
 
  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);
  }
 
  virtual Model::DescribeLocalGatewaysOutcome DescribeLocalGateways(const Model::DescribeLocalGatewaysRequest& request = {}) const;
 
  template <typename DescribeLocalGatewaysRequestT = Model::DescribeLocalGatewaysRequest>
  Model::DescribeLocalGatewaysOutcomeCallable DescribeLocalGatewaysCallable(const DescribeLocalGatewaysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLocalGateways, request);
  }
 
  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);
  }
 
  virtual Model::DescribeLockedSnapshotsOutcome DescribeLockedSnapshots(const Model::DescribeLockedSnapshotsRequest& request = {}) const;
 
  template <typename DescribeLockedSnapshotsRequestT = Model::DescribeLockedSnapshotsRequest>
  Model::DescribeLockedSnapshotsOutcomeCallable DescribeLockedSnapshotsCallable(const DescribeLockedSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeLockedSnapshots, request);
  }
 
  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);
  }
 
  virtual Model::DescribeMacHostsOutcome DescribeMacHosts(const Model::DescribeMacHostsRequest& request = {}) const;
 
  template <typename DescribeMacHostsRequestT = Model::DescribeMacHostsRequest>
  Model::DescribeMacHostsOutcomeCallable DescribeMacHostsCallable(const DescribeMacHostsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeMacHosts, request);
  }
 
  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);
  }
 
  virtual Model::DescribeMacModificationTasksOutcome DescribeMacModificationTasks(
      const Model::DescribeMacModificationTasksRequest& request = {}) const;
 
  template <typename DescribeMacModificationTasksRequestT = Model::DescribeMacModificationTasksRequest>
  Model::DescribeMacModificationTasksOutcomeCallable DescribeMacModificationTasksCallable(
      const DescribeMacModificationTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeMacModificationTasks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeManagedPrefixListsOutcome DescribeManagedPrefixLists(
      const Model::DescribeManagedPrefixListsRequest& request = {}) const;
 
  template <typename DescribeManagedPrefixListsRequestT = Model::DescribeManagedPrefixListsRequest>
  Model::DescribeManagedPrefixListsOutcomeCallable DescribeManagedPrefixListsCallable(
      const DescribeManagedPrefixListsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeManagedPrefixLists, request);
  }
 
  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);
  }
 
  virtual Model::DescribeMovingAddressesOutcome DescribeMovingAddresses(const Model::DescribeMovingAddressesRequest& request = {}) const;
 
  template <typename DescribeMovingAddressesRequestT = Model::DescribeMovingAddressesRequest>
  Model::DescribeMovingAddressesOutcomeCallable DescribeMovingAddressesCallable(const DescribeMovingAddressesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeMovingAddresses, request);
  }
 
  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);
  }
 
  virtual Model::DescribeNatGatewaysOutcome DescribeNatGateways(const Model::DescribeNatGatewaysRequest& request = {}) const;
 
  template <typename DescribeNatGatewaysRequestT = Model::DescribeNatGatewaysRequest>
  Model::DescribeNatGatewaysOutcomeCallable DescribeNatGatewaysCallable(const DescribeNatGatewaysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeNatGateways, request);
  }
 
  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);
  }
 
  virtual Model::DescribeNetworkAclsOutcome DescribeNetworkAcls(const Model::DescribeNetworkAclsRequest& request = {}) const;
 
  template <typename DescribeNetworkAclsRequestT = Model::DescribeNetworkAclsRequest>
  Model::DescribeNetworkAclsOutcomeCallable DescribeNetworkAclsCallable(const DescribeNetworkAclsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeNetworkAcls, request);
  }
 
  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);
  }
 
  virtual Model::DescribeNetworkInsightsAccessScopeAnalysesOutcome DescribeNetworkInsightsAccessScopeAnalyses(
      const Model::DescribeNetworkInsightsAccessScopeAnalysesRequest& request = {}) const;
 
  template <typename DescribeNetworkInsightsAccessScopeAnalysesRequestT = Model::DescribeNetworkInsightsAccessScopeAnalysesRequest>
  Model::DescribeNetworkInsightsAccessScopeAnalysesOutcomeCallable DescribeNetworkInsightsAccessScopeAnalysesCallable(
      const DescribeNetworkInsightsAccessScopeAnalysesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeNetworkInsightsAccessScopeAnalyses, request);
  }
 
  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);
  }
 
  virtual Model::DescribeNetworkInsightsAccessScopesOutcome DescribeNetworkInsightsAccessScopes(
      const Model::DescribeNetworkInsightsAccessScopesRequest& request = {}) const;
 
  template <typename DescribeNetworkInsightsAccessScopesRequestT = Model::DescribeNetworkInsightsAccessScopesRequest>
  Model::DescribeNetworkInsightsAccessScopesOutcomeCallable DescribeNetworkInsightsAccessScopesCallable(
      const DescribeNetworkInsightsAccessScopesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeNetworkInsightsAccessScopes, request);
  }
 
  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);
  }
 
  virtual Model::DescribeNetworkInsightsAnalysesOutcome DescribeNetworkInsightsAnalyses(
      const Model::DescribeNetworkInsightsAnalysesRequest& request = {}) const;
 
  template <typename DescribeNetworkInsightsAnalysesRequestT = Model::DescribeNetworkInsightsAnalysesRequest>
  Model::DescribeNetworkInsightsAnalysesOutcomeCallable DescribeNetworkInsightsAnalysesCallable(
      const DescribeNetworkInsightsAnalysesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeNetworkInsightsAnalyses, request);
  }
 
  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);
  }
 
  virtual Model::DescribeNetworkInsightsPathsOutcome DescribeNetworkInsightsPaths(
      const Model::DescribeNetworkInsightsPathsRequest& request = {}) const;
 
  template <typename DescribeNetworkInsightsPathsRequestT = Model::DescribeNetworkInsightsPathsRequest>
  Model::DescribeNetworkInsightsPathsOutcomeCallable DescribeNetworkInsightsPathsCallable(
      const DescribeNetworkInsightsPathsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeNetworkInsightsPaths, request);
  }
 
  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);
  }
 
  virtual Model::DescribeNetworkInterfaceAttributeOutcome DescribeNetworkInterfaceAttribute(
      const Model::DescribeNetworkInterfaceAttributeRequest& request) const;
 
  template <typename DescribeNetworkInterfaceAttributeRequestT = Model::DescribeNetworkInterfaceAttributeRequest>
  Model::DescribeNetworkInterfaceAttributeOutcomeCallable DescribeNetworkInterfaceAttributeCallable(
      const DescribeNetworkInterfaceAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeNetworkInterfaceAttribute, request);
  }
 
  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);
  }
 
  virtual Model::DescribeNetworkInterfacePermissionsOutcome DescribeNetworkInterfacePermissions(
      const Model::DescribeNetworkInterfacePermissionsRequest& request = {}) const;
 
  template <typename DescribeNetworkInterfacePermissionsRequestT = Model::DescribeNetworkInterfacePermissionsRequest>
  Model::DescribeNetworkInterfacePermissionsOutcomeCallable DescribeNetworkInterfacePermissionsCallable(
      const DescribeNetworkInterfacePermissionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeNetworkInterfacePermissions, request);
  }
 
  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);
  }
 
  virtual Model::DescribeNetworkInterfacesOutcome DescribeNetworkInterfaces(
      const Model::DescribeNetworkInterfacesRequest& request = {}) const;
 
  template <typename DescribeNetworkInterfacesRequestT = Model::DescribeNetworkInterfacesRequest>
  Model::DescribeNetworkInterfacesOutcomeCallable DescribeNetworkInterfacesCallable(
      const DescribeNetworkInterfacesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeNetworkInterfaces, request);
  }
 
  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);
  }
 
  virtual Model::DescribeOutpostLagsOutcome DescribeOutpostLags(const Model::DescribeOutpostLagsRequest& request = {}) const;
 
  template <typename DescribeOutpostLagsRequestT = Model::DescribeOutpostLagsRequest>
  Model::DescribeOutpostLagsOutcomeCallable DescribeOutpostLagsCallable(const DescribeOutpostLagsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeOutpostLags, request);
  }
 
  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);
  }
 
  virtual Model::DescribePlacementGroupsOutcome DescribePlacementGroups(const Model::DescribePlacementGroupsRequest& request = {}) const;
 
  template <typename DescribePlacementGroupsRequestT = Model::DescribePlacementGroupsRequest>
  Model::DescribePlacementGroupsOutcomeCallable DescribePlacementGroupsCallable(const DescribePlacementGroupsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribePlacementGroups, request);
  }
 
  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);
  }
 
  virtual Model::DescribePrefixListsOutcome DescribePrefixLists(const Model::DescribePrefixListsRequest& request = {}) const;
 
  template <typename DescribePrefixListsRequestT = Model::DescribePrefixListsRequest>
  Model::DescribePrefixListsOutcomeCallable DescribePrefixListsCallable(const DescribePrefixListsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribePrefixLists, request);
  }
 
  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);
  }
 
  virtual Model::DescribePrincipalIdFormatOutcome DescribePrincipalIdFormat(
      const Model::DescribePrincipalIdFormatRequest& request = {}) const;
 
  template <typename DescribePrincipalIdFormatRequestT = Model::DescribePrincipalIdFormatRequest>
  Model::DescribePrincipalIdFormatOutcomeCallable DescribePrincipalIdFormatCallable(
      const DescribePrincipalIdFormatRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribePrincipalIdFormat, request);
  }
 
  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);
  }
 
  virtual Model::DescribePublicIpv4PoolsOutcome DescribePublicIpv4Pools(const Model::DescribePublicIpv4PoolsRequest& request = {}) const;
 
  template <typename DescribePublicIpv4PoolsRequestT = Model::DescribePublicIpv4PoolsRequest>
  Model::DescribePublicIpv4PoolsOutcomeCallable DescribePublicIpv4PoolsCallable(const DescribePublicIpv4PoolsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribePublicIpv4Pools, request);
  }
 
  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);
  }
 
  virtual Model::DescribeRegionsOutcome DescribeRegions(const Model::DescribeRegionsRequest& request = {}) const;
 
  template <typename DescribeRegionsRequestT = Model::DescribeRegionsRequest>
  Model::DescribeRegionsOutcomeCallable DescribeRegionsCallable(const DescribeRegionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeRegions, request);
  }
 
  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);
  }
 
  virtual Model::DescribeReplaceRootVolumeTasksOutcome DescribeReplaceRootVolumeTasks(
      const Model::DescribeReplaceRootVolumeTasksRequest& request = {}) const;
 
  template <typename DescribeReplaceRootVolumeTasksRequestT = Model::DescribeReplaceRootVolumeTasksRequest>
  Model::DescribeReplaceRootVolumeTasksOutcomeCallable DescribeReplaceRootVolumeTasksCallable(
      const DescribeReplaceRootVolumeTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeReplaceRootVolumeTasks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeReservedInstancesOutcome DescribeReservedInstances(
      const Model::DescribeReservedInstancesRequest& request = {}) const;
 
  template <typename DescribeReservedInstancesRequestT = Model::DescribeReservedInstancesRequest>
  Model::DescribeReservedInstancesOutcomeCallable DescribeReservedInstancesCallable(
      const DescribeReservedInstancesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeReservedInstances, request);
  }
 
  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);
  }
 
  virtual Model::DescribeReservedInstancesListingsOutcome DescribeReservedInstancesListings(
      const Model::DescribeReservedInstancesListingsRequest& request = {}) const;
 
  template <typename DescribeReservedInstancesListingsRequestT = Model::DescribeReservedInstancesListingsRequest>
  Model::DescribeReservedInstancesListingsOutcomeCallable DescribeReservedInstancesListingsCallable(
      const DescribeReservedInstancesListingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeReservedInstancesListings, request);
  }
 
  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);
  }
 
  virtual Model::DescribeReservedInstancesModificationsOutcome DescribeReservedInstancesModifications(
      const Model::DescribeReservedInstancesModificationsRequest& request = {}) const;
 
  template <typename DescribeReservedInstancesModificationsRequestT = Model::DescribeReservedInstancesModificationsRequest>
  Model::DescribeReservedInstancesModificationsOutcomeCallable DescribeReservedInstancesModificationsCallable(
      const DescribeReservedInstancesModificationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeReservedInstancesModifications, request);
  }
 
  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);
  }
 
  virtual Model::DescribeReservedInstancesOfferingsOutcome DescribeReservedInstancesOfferings(
      const Model::DescribeReservedInstancesOfferingsRequest& request = {}) const;
 
  template <typename DescribeReservedInstancesOfferingsRequestT = Model::DescribeReservedInstancesOfferingsRequest>
  Model::DescribeReservedInstancesOfferingsOutcomeCallable DescribeReservedInstancesOfferingsCallable(
      const DescribeReservedInstancesOfferingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeReservedInstancesOfferings, request);
  }
 
  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);
  }
 
  virtual Model::DescribeRouteServerEndpointsOutcome DescribeRouteServerEndpoints(
      const Model::DescribeRouteServerEndpointsRequest& request = {}) const;
 
  template <typename DescribeRouteServerEndpointsRequestT = Model::DescribeRouteServerEndpointsRequest>
  Model::DescribeRouteServerEndpointsOutcomeCallable DescribeRouteServerEndpointsCallable(
      const DescribeRouteServerEndpointsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeRouteServerEndpoints, request);
  }
 
  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);
  }
 
  virtual Model::DescribeRouteServerPeersOutcome DescribeRouteServerPeers(const Model::DescribeRouteServerPeersRequest& request = {}) const;
 
  template <typename DescribeRouteServerPeersRequestT = Model::DescribeRouteServerPeersRequest>
  Model::DescribeRouteServerPeersOutcomeCallable DescribeRouteServerPeersCallable(
      const DescribeRouteServerPeersRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeRouteServerPeers, request);
  }
 
  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);
  }
 
  virtual Model::DescribeRouteServersOutcome DescribeRouteServers(const Model::DescribeRouteServersRequest& request = {}) const;
 
  template <typename DescribeRouteServersRequestT = Model::DescribeRouteServersRequest>
  Model::DescribeRouteServersOutcomeCallable DescribeRouteServersCallable(const DescribeRouteServersRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeRouteServers, request);
  }
 
  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);
  }
 
  virtual Model::DescribeRouteTablesOutcome DescribeRouteTables(const Model::DescribeRouteTablesRequest& request = {}) const;
 
  template <typename DescribeRouteTablesRequestT = Model::DescribeRouteTablesRequest>
  Model::DescribeRouteTablesOutcomeCallable DescribeRouteTablesCallable(const DescribeRouteTablesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeRouteTables, request);
  }
 
  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);
  }
 
  virtual Model::DescribeScheduledInstanceAvailabilityOutcome DescribeScheduledInstanceAvailability(
      const Model::DescribeScheduledInstanceAvailabilityRequest& request) const;
 
  template <typename DescribeScheduledInstanceAvailabilityRequestT = Model::DescribeScheduledInstanceAvailabilityRequest>
  Model::DescribeScheduledInstanceAvailabilityOutcomeCallable DescribeScheduledInstanceAvailabilityCallable(
      const DescribeScheduledInstanceAvailabilityRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeScheduledInstanceAvailability, request);
  }
 
  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);
  }
 
  virtual Model::DescribeScheduledInstancesOutcome DescribeScheduledInstances(
      const Model::DescribeScheduledInstancesRequest& request = {}) const;
 
  template <typename DescribeScheduledInstancesRequestT = Model::DescribeScheduledInstancesRequest>
  Model::DescribeScheduledInstancesOutcomeCallable DescribeScheduledInstancesCallable(
      const DescribeScheduledInstancesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeScheduledInstances, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSecondaryInterfacesOutcome DescribeSecondaryInterfaces(
      const Model::DescribeSecondaryInterfacesRequest& request = {}) const;
 
  template <typename DescribeSecondaryInterfacesRequestT = Model::DescribeSecondaryInterfacesRequest>
  Model::DescribeSecondaryInterfacesOutcomeCallable DescribeSecondaryInterfacesCallable(
      const DescribeSecondaryInterfacesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecondaryInterfaces, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSecondaryNetworksOutcome DescribeSecondaryNetworks(
      const Model::DescribeSecondaryNetworksRequest& request = {}) const;
 
  template <typename DescribeSecondaryNetworksRequestT = Model::DescribeSecondaryNetworksRequest>
  Model::DescribeSecondaryNetworksOutcomeCallable DescribeSecondaryNetworksCallable(
      const DescribeSecondaryNetworksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecondaryNetworks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSecondarySubnetsOutcome DescribeSecondarySubnets(const Model::DescribeSecondarySubnetsRequest& request = {}) const;
 
  template <typename DescribeSecondarySubnetsRequestT = Model::DescribeSecondarySubnetsRequest>
  Model::DescribeSecondarySubnetsOutcomeCallable DescribeSecondarySubnetsCallable(
      const DescribeSecondarySubnetsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecondarySubnets, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSecurityGroupReferencesOutcome DescribeSecurityGroupReferences(
      const Model::DescribeSecurityGroupReferencesRequest& request) const;
 
  template <typename DescribeSecurityGroupReferencesRequestT = Model::DescribeSecurityGroupReferencesRequest>
  Model::DescribeSecurityGroupReferencesOutcomeCallable DescribeSecurityGroupReferencesCallable(
      const DescribeSecurityGroupReferencesRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeSecurityGroupReferences, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSecurityGroupRulesOutcome DescribeSecurityGroupRules(
      const Model::DescribeSecurityGroupRulesRequest& request = {}) const;
 
  template <typename DescribeSecurityGroupRulesRequestT = Model::DescribeSecurityGroupRulesRequest>
  Model::DescribeSecurityGroupRulesOutcomeCallable DescribeSecurityGroupRulesCallable(
      const DescribeSecurityGroupRulesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecurityGroupRules, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSecurityGroupVpcAssociationsOutcome DescribeSecurityGroupVpcAssociations(
      const Model::DescribeSecurityGroupVpcAssociationsRequest& request = {}) const;
 
  template <typename DescribeSecurityGroupVpcAssociationsRequestT = Model::DescribeSecurityGroupVpcAssociationsRequest>
  Model::DescribeSecurityGroupVpcAssociationsOutcomeCallable DescribeSecurityGroupVpcAssociationsCallable(
      const DescribeSecurityGroupVpcAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecurityGroupVpcAssociations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSecurityGroupsOutcome DescribeSecurityGroups(const Model::DescribeSecurityGroupsRequest& request = {}) const;
 
  template <typename DescribeSecurityGroupsRequestT = Model::DescribeSecurityGroupsRequest>
  Model::DescribeSecurityGroupsOutcomeCallable DescribeSecurityGroupsCallable(const DescribeSecurityGroupsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSecurityGroups, request);
  }
 
  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);
  }
 
  virtual Model::DescribeServiceLinkVirtualInterfacesOutcome DescribeServiceLinkVirtualInterfaces(
      const Model::DescribeServiceLinkVirtualInterfacesRequest& request = {}) const;
 
  template <typename DescribeServiceLinkVirtualInterfacesRequestT = Model::DescribeServiceLinkVirtualInterfacesRequest>
  Model::DescribeServiceLinkVirtualInterfacesOutcomeCallable DescribeServiceLinkVirtualInterfacesCallable(
      const DescribeServiceLinkVirtualInterfacesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeServiceLinkVirtualInterfaces, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSnapshotAttributeOutcome DescribeSnapshotAttribute(const Model::DescribeSnapshotAttributeRequest& request) const;
 
  template <typename DescribeSnapshotAttributeRequestT = Model::DescribeSnapshotAttributeRequest>
  Model::DescribeSnapshotAttributeOutcomeCallable DescribeSnapshotAttributeCallable(
      const DescribeSnapshotAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeSnapshotAttribute, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSnapshotTierStatusOutcome DescribeSnapshotTierStatus(
      const Model::DescribeSnapshotTierStatusRequest& request = {}) const;
 
  template <typename DescribeSnapshotTierStatusRequestT = Model::DescribeSnapshotTierStatusRequest>
  Model::DescribeSnapshotTierStatusOutcomeCallable DescribeSnapshotTierStatusCallable(
      const DescribeSnapshotTierStatusRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSnapshotTierStatus, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSnapshotsOutcome DescribeSnapshots(const Model::DescribeSnapshotsRequest& request = {}) const;
 
  template <typename DescribeSnapshotsRequestT = Model::DescribeSnapshotsRequest>
  Model::DescribeSnapshotsOutcomeCallable DescribeSnapshotsCallable(const DescribeSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSnapshots, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSpotDatafeedSubscriptionOutcome DescribeSpotDatafeedSubscription(
      const Model::DescribeSpotDatafeedSubscriptionRequest& request = {}) const;
 
  template <typename DescribeSpotDatafeedSubscriptionRequestT = Model::DescribeSpotDatafeedSubscriptionRequest>
  Model::DescribeSpotDatafeedSubscriptionOutcomeCallable DescribeSpotDatafeedSubscriptionCallable(
      const DescribeSpotDatafeedSubscriptionRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSpotDatafeedSubscription, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSpotFleetInstancesOutcome DescribeSpotFleetInstances(
      const Model::DescribeSpotFleetInstancesRequest& request) const;
 
  template <typename DescribeSpotFleetInstancesRequestT = Model::DescribeSpotFleetInstancesRequest>
  Model::DescribeSpotFleetInstancesOutcomeCallable DescribeSpotFleetInstancesCallable(
      const DescribeSpotFleetInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeSpotFleetInstances, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSpotFleetRequestHistoryOutcome DescribeSpotFleetRequestHistory(
      const Model::DescribeSpotFleetRequestHistoryRequest& request) const;
 
  template <typename DescribeSpotFleetRequestHistoryRequestT = Model::DescribeSpotFleetRequestHistoryRequest>
  Model::DescribeSpotFleetRequestHistoryOutcomeCallable DescribeSpotFleetRequestHistoryCallable(
      const DescribeSpotFleetRequestHistoryRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeSpotFleetRequestHistory, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSpotFleetRequestsOutcome DescribeSpotFleetRequests(
      const Model::DescribeSpotFleetRequestsRequest& request = {}) const;
 
  template <typename DescribeSpotFleetRequestsRequestT = Model::DescribeSpotFleetRequestsRequest>
  Model::DescribeSpotFleetRequestsOutcomeCallable DescribeSpotFleetRequestsCallable(
      const DescribeSpotFleetRequestsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSpotFleetRequests, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSpotInstanceRequestsOutcome DescribeSpotInstanceRequests(
      const Model::DescribeSpotInstanceRequestsRequest& request = {}) const;
 
  template <typename DescribeSpotInstanceRequestsRequestT = Model::DescribeSpotInstanceRequestsRequest>
  Model::DescribeSpotInstanceRequestsOutcomeCallable DescribeSpotInstanceRequestsCallable(
      const DescribeSpotInstanceRequestsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSpotInstanceRequests, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSpotPriceHistoryOutcome DescribeSpotPriceHistory(const Model::DescribeSpotPriceHistoryRequest& request = {}) const;
 
  template <typename DescribeSpotPriceHistoryRequestT = Model::DescribeSpotPriceHistoryRequest>
  Model::DescribeSpotPriceHistoryOutcomeCallable DescribeSpotPriceHistoryCallable(
      const DescribeSpotPriceHistoryRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSpotPriceHistory, request);
  }
 
  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);
  }
 
  virtual Model::DescribeStaleSecurityGroupsOutcome DescribeStaleSecurityGroups(
      const Model::DescribeStaleSecurityGroupsRequest& request) const;
 
  template <typename DescribeStaleSecurityGroupsRequestT = Model::DescribeStaleSecurityGroupsRequest>
  Model::DescribeStaleSecurityGroupsOutcomeCallable DescribeStaleSecurityGroupsCallable(
      const DescribeStaleSecurityGroupsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeStaleSecurityGroups, request);
  }
 
  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);
  }
 
  virtual Model::DescribeStoreImageTasksOutcome DescribeStoreImageTasks(const Model::DescribeStoreImageTasksRequest& request = {}) const;
 
  template <typename DescribeStoreImageTasksRequestT = Model::DescribeStoreImageTasksRequest>
  Model::DescribeStoreImageTasksOutcomeCallable DescribeStoreImageTasksCallable(const DescribeStoreImageTasksRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeStoreImageTasks, request);
  }
 
  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);
  }
 
  virtual Model::DescribeSubnetsOutcome DescribeSubnets(const Model::DescribeSubnetsRequest& request = {}) const;
 
  template <typename DescribeSubnetsRequestT = Model::DescribeSubnetsRequest>
  Model::DescribeSubnetsOutcomeCallable DescribeSubnetsCallable(const DescribeSubnetsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeSubnets, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request = {}) const;
 
  template <typename DescribeTagsRequestT = Model::DescribeTagsRequest>
  Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTags, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTrafficMirrorFilterRulesOutcome DescribeTrafficMirrorFilterRules(
      const Model::DescribeTrafficMirrorFilterRulesRequest& request = {}) const;
 
  template <typename DescribeTrafficMirrorFilterRulesRequestT = Model::DescribeTrafficMirrorFilterRulesRequest>
  Model::DescribeTrafficMirrorFilterRulesOutcomeCallable DescribeTrafficMirrorFilterRulesCallable(
      const DescribeTrafficMirrorFilterRulesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTrafficMirrorFilterRules, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTrafficMirrorFiltersOutcome DescribeTrafficMirrorFilters(
      const Model::DescribeTrafficMirrorFiltersRequest& request = {}) const;
 
  template <typename DescribeTrafficMirrorFiltersRequestT = Model::DescribeTrafficMirrorFiltersRequest>
  Model::DescribeTrafficMirrorFiltersOutcomeCallable DescribeTrafficMirrorFiltersCallable(
      const DescribeTrafficMirrorFiltersRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTrafficMirrorFilters, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTrafficMirrorSessionsOutcome DescribeTrafficMirrorSessions(
      const Model::DescribeTrafficMirrorSessionsRequest& request = {}) const;
 
  template <typename DescribeTrafficMirrorSessionsRequestT = Model::DescribeTrafficMirrorSessionsRequest>
  Model::DescribeTrafficMirrorSessionsOutcomeCallable DescribeTrafficMirrorSessionsCallable(
      const DescribeTrafficMirrorSessionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTrafficMirrorSessions, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTrafficMirrorTargetsOutcome DescribeTrafficMirrorTargets(
      const Model::DescribeTrafficMirrorTargetsRequest& request = {}) const;
 
  template <typename DescribeTrafficMirrorTargetsRequestT = Model::DescribeTrafficMirrorTargetsRequest>
  Model::DescribeTrafficMirrorTargetsOutcomeCallable DescribeTrafficMirrorTargetsCallable(
      const DescribeTrafficMirrorTargetsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTrafficMirrorTargets, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayAttachmentsOutcome DescribeTransitGatewayAttachments(
      const Model::DescribeTransitGatewayAttachmentsRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayAttachmentsRequestT = Model::DescribeTransitGatewayAttachmentsRequest>
  Model::DescribeTransitGatewayAttachmentsOutcomeCallable DescribeTransitGatewayAttachmentsCallable(
      const DescribeTransitGatewayAttachmentsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayAttachments, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayConnectPeersOutcome DescribeTransitGatewayConnectPeers(
      const Model::DescribeTransitGatewayConnectPeersRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayConnectPeersRequestT = Model::DescribeTransitGatewayConnectPeersRequest>
  Model::DescribeTransitGatewayConnectPeersOutcomeCallable DescribeTransitGatewayConnectPeersCallable(
      const DescribeTransitGatewayConnectPeersRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayConnectPeers, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayConnectsOutcome DescribeTransitGatewayConnects(
      const Model::DescribeTransitGatewayConnectsRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayConnectsRequestT = Model::DescribeTransitGatewayConnectsRequest>
  Model::DescribeTransitGatewayConnectsOutcomeCallable DescribeTransitGatewayConnectsCallable(
      const DescribeTransitGatewayConnectsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayConnects, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayMeteringPoliciesOutcome DescribeTransitGatewayMeteringPolicies(
      const Model::DescribeTransitGatewayMeteringPoliciesRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayMeteringPoliciesRequestT = Model::DescribeTransitGatewayMeteringPoliciesRequest>
  Model::DescribeTransitGatewayMeteringPoliciesOutcomeCallable DescribeTransitGatewayMeteringPoliciesCallable(
      const DescribeTransitGatewayMeteringPoliciesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayMeteringPolicies, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayMulticastDomainsOutcome DescribeTransitGatewayMulticastDomains(
      const Model::DescribeTransitGatewayMulticastDomainsRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayMulticastDomainsRequestT = Model::DescribeTransitGatewayMulticastDomainsRequest>
  Model::DescribeTransitGatewayMulticastDomainsOutcomeCallable DescribeTransitGatewayMulticastDomainsCallable(
      const DescribeTransitGatewayMulticastDomainsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayMulticastDomains, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayPeeringAttachmentsOutcome DescribeTransitGatewayPeeringAttachments(
      const Model::DescribeTransitGatewayPeeringAttachmentsRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayPeeringAttachmentsRequestT = Model::DescribeTransitGatewayPeeringAttachmentsRequest>
  Model::DescribeTransitGatewayPeeringAttachmentsOutcomeCallable DescribeTransitGatewayPeeringAttachmentsCallable(
      const DescribeTransitGatewayPeeringAttachmentsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayPeeringAttachments, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayPolicyTablesOutcome DescribeTransitGatewayPolicyTables(
      const Model::DescribeTransitGatewayPolicyTablesRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayPolicyTablesRequestT = Model::DescribeTransitGatewayPolicyTablesRequest>
  Model::DescribeTransitGatewayPolicyTablesOutcomeCallable DescribeTransitGatewayPolicyTablesCallable(
      const DescribeTransitGatewayPolicyTablesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayPolicyTables, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayRouteTableAnnouncementsOutcome DescribeTransitGatewayRouteTableAnnouncements(
      const Model::DescribeTransitGatewayRouteTableAnnouncementsRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayRouteTableAnnouncementsRequestT = Model::DescribeTransitGatewayRouteTableAnnouncementsRequest>
  Model::DescribeTransitGatewayRouteTableAnnouncementsOutcomeCallable DescribeTransitGatewayRouteTableAnnouncementsCallable(
      const DescribeTransitGatewayRouteTableAnnouncementsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayRouteTableAnnouncements, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayRouteTablesOutcome DescribeTransitGatewayRouteTables(
      const Model::DescribeTransitGatewayRouteTablesRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayRouteTablesRequestT = Model::DescribeTransitGatewayRouteTablesRequest>
  Model::DescribeTransitGatewayRouteTablesOutcomeCallable DescribeTransitGatewayRouteTablesCallable(
      const DescribeTransitGatewayRouteTablesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayRouteTables, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewayVpcAttachmentsOutcome DescribeTransitGatewayVpcAttachments(
      const Model::DescribeTransitGatewayVpcAttachmentsRequest& request = {}) const;
 
  template <typename DescribeTransitGatewayVpcAttachmentsRequestT = Model::DescribeTransitGatewayVpcAttachmentsRequest>
  Model::DescribeTransitGatewayVpcAttachmentsOutcomeCallable DescribeTransitGatewayVpcAttachmentsCallable(
      const DescribeTransitGatewayVpcAttachmentsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGatewayVpcAttachments, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTransitGatewaysOutcome DescribeTransitGateways(const Model::DescribeTransitGatewaysRequest& request = {}) const;
 
  template <typename DescribeTransitGatewaysRequestT = Model::DescribeTransitGatewaysRequest>
  Model::DescribeTransitGatewaysOutcomeCallable DescribeTransitGatewaysCallable(const DescribeTransitGatewaysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTransitGateways, request);
  }
 
  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);
  }
 
  virtual Model::DescribeTrunkInterfaceAssociationsOutcome DescribeTrunkInterfaceAssociations(
      const Model::DescribeTrunkInterfaceAssociationsRequest& request = {}) const;
 
  template <typename DescribeTrunkInterfaceAssociationsRequestT = Model::DescribeTrunkInterfaceAssociationsRequest>
  Model::DescribeTrunkInterfaceAssociationsOutcomeCallable DescribeTrunkInterfaceAssociationsCallable(
      const DescribeTrunkInterfaceAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeTrunkInterfaceAssociations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVerifiedAccessEndpointsOutcome DescribeVerifiedAccessEndpoints(
      const Model::DescribeVerifiedAccessEndpointsRequest& request = {}) const;
 
  template <typename DescribeVerifiedAccessEndpointsRequestT = Model::DescribeVerifiedAccessEndpointsRequest>
  Model::DescribeVerifiedAccessEndpointsOutcomeCallable DescribeVerifiedAccessEndpointsCallable(
      const DescribeVerifiedAccessEndpointsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVerifiedAccessEndpoints, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVerifiedAccessGroupsOutcome DescribeVerifiedAccessGroups(
      const Model::DescribeVerifiedAccessGroupsRequest& request = {}) const;
 
  template <typename DescribeVerifiedAccessGroupsRequestT = Model::DescribeVerifiedAccessGroupsRequest>
  Model::DescribeVerifiedAccessGroupsOutcomeCallable DescribeVerifiedAccessGroupsCallable(
      const DescribeVerifiedAccessGroupsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVerifiedAccessGroups, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVerifiedAccessInstanceLoggingConfigurationsOutcome DescribeVerifiedAccessInstanceLoggingConfigurations(
      const Model::DescribeVerifiedAccessInstanceLoggingConfigurationsRequest& request = {}) const;
 
  template <typename DescribeVerifiedAccessInstanceLoggingConfigurationsRequestT =
                Model::DescribeVerifiedAccessInstanceLoggingConfigurationsRequest>
  Model::DescribeVerifiedAccessInstanceLoggingConfigurationsOutcomeCallable DescribeVerifiedAccessInstanceLoggingConfigurationsCallable(
      const DescribeVerifiedAccessInstanceLoggingConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVerifiedAccessInstanceLoggingConfigurations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVerifiedAccessInstancesOutcome DescribeVerifiedAccessInstances(
      const Model::DescribeVerifiedAccessInstancesRequest& request = {}) const;
 
  template <typename DescribeVerifiedAccessInstancesRequestT = Model::DescribeVerifiedAccessInstancesRequest>
  Model::DescribeVerifiedAccessInstancesOutcomeCallable DescribeVerifiedAccessInstancesCallable(
      const DescribeVerifiedAccessInstancesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVerifiedAccessInstances, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVerifiedAccessTrustProvidersOutcome DescribeVerifiedAccessTrustProviders(
      const Model::DescribeVerifiedAccessTrustProvidersRequest& request = {}) const;
 
  template <typename DescribeVerifiedAccessTrustProvidersRequestT = Model::DescribeVerifiedAccessTrustProvidersRequest>
  Model::DescribeVerifiedAccessTrustProvidersOutcomeCallable DescribeVerifiedAccessTrustProvidersCallable(
      const DescribeVerifiedAccessTrustProvidersRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVerifiedAccessTrustProviders, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVolumeAttributeOutcome DescribeVolumeAttribute(const Model::DescribeVolumeAttributeRequest& request) const;
 
  template <typename DescribeVolumeAttributeRequestT = Model::DescribeVolumeAttributeRequest>
  Model::DescribeVolumeAttributeOutcomeCallable DescribeVolumeAttributeCallable(const DescribeVolumeAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeVolumeAttribute, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVolumeStatusOutcome DescribeVolumeStatus(const Model::DescribeVolumeStatusRequest& request = {}) const;
 
  template <typename DescribeVolumeStatusRequestT = Model::DescribeVolumeStatusRequest>
  Model::DescribeVolumeStatusOutcomeCallable DescribeVolumeStatusCallable(const DescribeVolumeStatusRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVolumeStatus, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVolumesOutcome DescribeVolumes(const Model::DescribeVolumesRequest& request = {}) const;
 
  template <typename DescribeVolumesRequestT = Model::DescribeVolumesRequest>
  Model::DescribeVolumesOutcomeCallable DescribeVolumesCallable(const DescribeVolumesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVolumes, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVolumesModificationsOutcome DescribeVolumesModifications(
      const Model::DescribeVolumesModificationsRequest& request = {}) const;
 
  template <typename DescribeVolumesModificationsRequestT = Model::DescribeVolumesModificationsRequest>
  Model::DescribeVolumesModificationsOutcomeCallable DescribeVolumesModificationsCallable(
      const DescribeVolumesModificationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVolumesModifications, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcAttributeOutcome DescribeVpcAttribute(const Model::DescribeVpcAttributeRequest& request) const;
 
  template <typename DescribeVpcAttributeRequestT = Model::DescribeVpcAttributeRequest>
  Model::DescribeVpcAttributeOutcomeCallable DescribeVpcAttributeCallable(const DescribeVpcAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeVpcAttribute, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcBlockPublicAccessExclusionsOutcome DescribeVpcBlockPublicAccessExclusions(
      const Model::DescribeVpcBlockPublicAccessExclusionsRequest& request = {}) const;
 
  template <typename DescribeVpcBlockPublicAccessExclusionsRequestT = Model::DescribeVpcBlockPublicAccessExclusionsRequest>
  Model::DescribeVpcBlockPublicAccessExclusionsOutcomeCallable DescribeVpcBlockPublicAccessExclusionsCallable(
      const DescribeVpcBlockPublicAccessExclusionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcBlockPublicAccessExclusions, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcBlockPublicAccessOptionsOutcome DescribeVpcBlockPublicAccessOptions(
      const Model::DescribeVpcBlockPublicAccessOptionsRequest& request = {}) const;
 
  template <typename DescribeVpcBlockPublicAccessOptionsRequestT = Model::DescribeVpcBlockPublicAccessOptionsRequest>
  Model::DescribeVpcBlockPublicAccessOptionsOutcomeCallable DescribeVpcBlockPublicAccessOptionsCallable(
      const DescribeVpcBlockPublicAccessOptionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcBlockPublicAccessOptions, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcClassicLinkOutcome DescribeVpcClassicLink(const Model::DescribeVpcClassicLinkRequest& request = {}) const;
 
  template <typename DescribeVpcClassicLinkRequestT = Model::DescribeVpcClassicLinkRequest>
  Model::DescribeVpcClassicLinkOutcomeCallable DescribeVpcClassicLinkCallable(const DescribeVpcClassicLinkRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcClassicLink, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcClassicLinkDnsSupportOutcome DescribeVpcClassicLinkDnsSupport(
      const Model::DescribeVpcClassicLinkDnsSupportRequest& request = {}) const;
 
  template <typename DescribeVpcClassicLinkDnsSupportRequestT = Model::DescribeVpcClassicLinkDnsSupportRequest>
  Model::DescribeVpcClassicLinkDnsSupportOutcomeCallable DescribeVpcClassicLinkDnsSupportCallable(
      const DescribeVpcClassicLinkDnsSupportRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcClassicLinkDnsSupport, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcEncryptionControlsOutcome DescribeVpcEncryptionControls(
      const Model::DescribeVpcEncryptionControlsRequest& request = {}) const;
 
  template <typename DescribeVpcEncryptionControlsRequestT = Model::DescribeVpcEncryptionControlsRequest>
  Model::DescribeVpcEncryptionControlsOutcomeCallable DescribeVpcEncryptionControlsCallable(
      const DescribeVpcEncryptionControlsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcEncryptionControls, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcEndpointAssociationsOutcome DescribeVpcEndpointAssociations(
      const Model::DescribeVpcEndpointAssociationsRequest& request = {}) const;
 
  template <typename DescribeVpcEndpointAssociationsRequestT = Model::DescribeVpcEndpointAssociationsRequest>
  Model::DescribeVpcEndpointAssociationsOutcomeCallable DescribeVpcEndpointAssociationsCallable(
      const DescribeVpcEndpointAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcEndpointAssociations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcEndpointConnectionNotificationsOutcome DescribeVpcEndpointConnectionNotifications(
      const Model::DescribeVpcEndpointConnectionNotificationsRequest& request = {}) const;
 
  template <typename DescribeVpcEndpointConnectionNotificationsRequestT = Model::DescribeVpcEndpointConnectionNotificationsRequest>
  Model::DescribeVpcEndpointConnectionNotificationsOutcomeCallable DescribeVpcEndpointConnectionNotificationsCallable(
      const DescribeVpcEndpointConnectionNotificationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcEndpointConnectionNotifications, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcEndpointConnectionsOutcome DescribeVpcEndpointConnections(
      const Model::DescribeVpcEndpointConnectionsRequest& request = {}) const;
 
  template <typename DescribeVpcEndpointConnectionsRequestT = Model::DescribeVpcEndpointConnectionsRequest>
  Model::DescribeVpcEndpointConnectionsOutcomeCallable DescribeVpcEndpointConnectionsCallable(
      const DescribeVpcEndpointConnectionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcEndpointConnections, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcEndpointServiceConfigurationsOutcome DescribeVpcEndpointServiceConfigurations(
      const Model::DescribeVpcEndpointServiceConfigurationsRequest& request = {}) const;
 
  template <typename DescribeVpcEndpointServiceConfigurationsRequestT = Model::DescribeVpcEndpointServiceConfigurationsRequest>
  Model::DescribeVpcEndpointServiceConfigurationsOutcomeCallable DescribeVpcEndpointServiceConfigurationsCallable(
      const DescribeVpcEndpointServiceConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcEndpointServiceConfigurations, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcEndpointServicePermissionsOutcome DescribeVpcEndpointServicePermissions(
      const Model::DescribeVpcEndpointServicePermissionsRequest& request) const;
 
  template <typename DescribeVpcEndpointServicePermissionsRequestT = Model::DescribeVpcEndpointServicePermissionsRequest>
  Model::DescribeVpcEndpointServicePermissionsOutcomeCallable DescribeVpcEndpointServicePermissionsCallable(
      const DescribeVpcEndpointServicePermissionsRequestT& request) const {
    return SubmitCallable(&EC2Client::DescribeVpcEndpointServicePermissions, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcEndpointServicesOutcome DescribeVpcEndpointServices(
      const Model::DescribeVpcEndpointServicesRequest& request = {}) const;
 
  template <typename DescribeVpcEndpointServicesRequestT = Model::DescribeVpcEndpointServicesRequest>
  Model::DescribeVpcEndpointServicesOutcomeCallable DescribeVpcEndpointServicesCallable(
      const DescribeVpcEndpointServicesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcEndpointServices, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcEndpointsOutcome DescribeVpcEndpoints(const Model::DescribeVpcEndpointsRequest& request = {}) const;
 
  template <typename DescribeVpcEndpointsRequestT = Model::DescribeVpcEndpointsRequest>
  Model::DescribeVpcEndpointsOutcomeCallable DescribeVpcEndpointsCallable(const DescribeVpcEndpointsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcEndpoints, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcPeeringConnectionsOutcome DescribeVpcPeeringConnections(
      const Model::DescribeVpcPeeringConnectionsRequest& request = {}) const;
 
  template <typename DescribeVpcPeeringConnectionsRequestT = Model::DescribeVpcPeeringConnectionsRequest>
  Model::DescribeVpcPeeringConnectionsOutcomeCallable DescribeVpcPeeringConnectionsCallable(
      const DescribeVpcPeeringConnectionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcPeeringConnections, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpcsOutcome DescribeVpcs(const Model::DescribeVpcsRequest& request = {}) const;
 
  template <typename DescribeVpcsRequestT = Model::DescribeVpcsRequest>
  Model::DescribeVpcsOutcomeCallable DescribeVpcsCallable(const DescribeVpcsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpcs, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpnConcentratorsOutcome DescribeVpnConcentrators(const Model::DescribeVpnConcentratorsRequest& request = {}) const;
 
  template <typename DescribeVpnConcentratorsRequestT = Model::DescribeVpnConcentratorsRequest>
  Model::DescribeVpnConcentratorsOutcomeCallable DescribeVpnConcentratorsCallable(
      const DescribeVpnConcentratorsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpnConcentrators, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpnConnectionsOutcome DescribeVpnConnections(const Model::DescribeVpnConnectionsRequest& request = {}) const;
 
  template <typename DescribeVpnConnectionsRequestT = Model::DescribeVpnConnectionsRequest>
  Model::DescribeVpnConnectionsOutcomeCallable DescribeVpnConnectionsCallable(const DescribeVpnConnectionsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpnConnections, request);
  }
 
  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);
  }
 
  virtual Model::DescribeVpnGatewaysOutcome DescribeVpnGateways(const Model::DescribeVpnGatewaysRequest& request = {}) const;
 
  template <typename DescribeVpnGatewaysRequestT = Model::DescribeVpnGatewaysRequest>
  Model::DescribeVpnGatewaysOutcomeCallable DescribeVpnGatewaysCallable(const DescribeVpnGatewaysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DescribeVpnGateways, request);
  }
 
  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);
  }
 
  virtual Model::DetachClassicLinkVpcOutcome DetachClassicLinkVpc(const Model::DetachClassicLinkVpcRequest& request) const;
 
  template <typename DetachClassicLinkVpcRequestT = Model::DetachClassicLinkVpcRequest>
  Model::DetachClassicLinkVpcOutcomeCallable DetachClassicLinkVpcCallable(const DetachClassicLinkVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::DetachClassicLinkVpc, request);
  }
 
  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);
  }
 
  virtual Model::DetachImageWatermarkOutcome DetachImageWatermark(const Model::DetachImageWatermarkRequest& request) const;
 
  template <typename DetachImageWatermarkRequestT = Model::DetachImageWatermarkRequest>
  Model::DetachImageWatermarkOutcomeCallable DetachImageWatermarkCallable(const DetachImageWatermarkRequestT& request) const {
    return SubmitCallable(&EC2Client::DetachImageWatermark, request);
  }
 
  template <typename DetachImageWatermarkRequestT = Model::DetachImageWatermarkRequest>
  void DetachImageWatermarkAsync(const DetachImageWatermarkRequestT& request, const DetachImageWatermarkResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::DetachImageWatermark, request, handler, context);
  }
 
  virtual Model::DetachInternetGatewayOutcome DetachInternetGateway(const Model::DetachInternetGatewayRequest& request) const;
 
  template <typename DetachInternetGatewayRequestT = Model::DetachInternetGatewayRequest>
  Model::DetachInternetGatewayOutcomeCallable DetachInternetGatewayCallable(const DetachInternetGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::DetachInternetGateway, request);
  }
 
  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);
  }
 
  virtual Model::DetachNetworkInterfaceOutcome DetachNetworkInterface(const Model::DetachNetworkInterfaceRequest& request) const;
 
  template <typename DetachNetworkInterfaceRequestT = Model::DetachNetworkInterfaceRequest>
  Model::DetachNetworkInterfaceOutcomeCallable DetachNetworkInterfaceCallable(const DetachNetworkInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::DetachNetworkInterface, request);
  }
 
  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);
  }
 
  virtual Model::DetachVerifiedAccessTrustProviderOutcome DetachVerifiedAccessTrustProvider(
      const Model::DetachVerifiedAccessTrustProviderRequest& request) const;
 
  template <typename DetachVerifiedAccessTrustProviderRequestT = Model::DetachVerifiedAccessTrustProviderRequest>
  Model::DetachVerifiedAccessTrustProviderOutcomeCallable DetachVerifiedAccessTrustProviderCallable(
      const DetachVerifiedAccessTrustProviderRequestT& request) const {
    return SubmitCallable(&EC2Client::DetachVerifiedAccessTrustProvider, request);
  }
 
  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);
  }
 
  virtual Model::DetachVolumeOutcome DetachVolume(const Model::DetachVolumeRequest& request) const;
 
  template <typename DetachVolumeRequestT = Model::DetachVolumeRequest>
  Model::DetachVolumeOutcomeCallable DetachVolumeCallable(const DetachVolumeRequestT& request) const {
    return SubmitCallable(&EC2Client::DetachVolume, request);
  }
 
  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);
  }
 
  virtual Model::DetachVpnGatewayOutcome DetachVpnGateway(const Model::DetachVpnGatewayRequest& request) const;
 
  template <typename DetachVpnGatewayRequestT = Model::DetachVpnGatewayRequest>
  Model::DetachVpnGatewayOutcomeCallable DetachVpnGatewayCallable(const DetachVpnGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::DetachVpnGateway, request);
  }
 
  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);
  }
 
  virtual Model::DisableAddressTransferOutcome DisableAddressTransfer(const Model::DisableAddressTransferRequest& request) const;
 
  template <typename DisableAddressTransferRequestT = Model::DisableAddressTransferRequest>
  Model::DisableAddressTransferOutcomeCallable DisableAddressTransferCallable(const DisableAddressTransferRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableAddressTransfer, request);
  }
 
  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);
  }
 
  virtual Model::DisableAllowedImagesSettingsOutcome DisableAllowedImagesSettings(
      const Model::DisableAllowedImagesSettingsRequest& request = {}) const;
 
  template <typename DisableAllowedImagesSettingsRequestT = Model::DisableAllowedImagesSettingsRequest>
  Model::DisableAllowedImagesSettingsOutcomeCallable DisableAllowedImagesSettingsCallable(
      const DisableAllowedImagesSettingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableAllowedImagesSettings, request);
  }
 
  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);
  }
 
  virtual Model::DisableAwsNetworkPerformanceMetricSubscriptionOutcome DisableAwsNetworkPerformanceMetricSubscription(
      const Model::DisableAwsNetworkPerformanceMetricSubscriptionRequest& request = {}) const;
 
  template <typename DisableAwsNetworkPerformanceMetricSubscriptionRequestT = Model::DisableAwsNetworkPerformanceMetricSubscriptionRequest>
  Model::DisableAwsNetworkPerformanceMetricSubscriptionOutcomeCallable DisableAwsNetworkPerformanceMetricSubscriptionCallable(
      const DisableAwsNetworkPerformanceMetricSubscriptionRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableAwsNetworkPerformanceMetricSubscription, request);
  }
 
  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);
  }
 
  virtual Model::DisableCapacityManagerOutcome DisableCapacityManager(const Model::DisableCapacityManagerRequest& request = {}) const;
 
  template <typename DisableCapacityManagerRequestT = Model::DisableCapacityManagerRequest>
  Model::DisableCapacityManagerOutcomeCallable DisableCapacityManagerCallable(const DisableCapacityManagerRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableCapacityManager, request);
  }
 
  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);
  }
 
  virtual Model::DisableEbsEncryptionByDefaultOutcome DisableEbsEncryptionByDefault(
      const Model::DisableEbsEncryptionByDefaultRequest& request = {}) const;
 
  template <typename DisableEbsEncryptionByDefaultRequestT = Model::DisableEbsEncryptionByDefaultRequest>
  Model::DisableEbsEncryptionByDefaultOutcomeCallable DisableEbsEncryptionByDefaultCallable(
      const DisableEbsEncryptionByDefaultRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableEbsEncryptionByDefault, request);
  }
 
  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);
  }
 
  virtual Model::DisableFastLaunchOutcome DisableFastLaunch(const Model::DisableFastLaunchRequest& request) const;
 
  template <typename DisableFastLaunchRequestT = Model::DisableFastLaunchRequest>
  Model::DisableFastLaunchOutcomeCallable DisableFastLaunchCallable(const DisableFastLaunchRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableFastLaunch, request);
  }
 
  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);
  }
 
  virtual Model::DisableFastSnapshotRestoresOutcome DisableFastSnapshotRestores(
      const Model::DisableFastSnapshotRestoresRequest& request) const;
 
  template <typename DisableFastSnapshotRestoresRequestT = Model::DisableFastSnapshotRestoresRequest>
  Model::DisableFastSnapshotRestoresOutcomeCallable DisableFastSnapshotRestoresCallable(
      const DisableFastSnapshotRestoresRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableFastSnapshotRestores, request);
  }
 
  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);
  }
 
  virtual Model::DisableImageOutcome DisableImage(const Model::DisableImageRequest& request) const;
 
  template <typename DisableImageRequestT = Model::DisableImageRequest>
  Model::DisableImageOutcomeCallable DisableImageCallable(const DisableImageRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableImage, request);
  }
 
  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);
  }
 
  virtual Model::DisableImageBlockPublicAccessOutcome DisableImageBlockPublicAccess(
      const Model::DisableImageBlockPublicAccessRequest& request = {}) const;
 
  template <typename DisableImageBlockPublicAccessRequestT = Model::DisableImageBlockPublicAccessRequest>
  Model::DisableImageBlockPublicAccessOutcomeCallable DisableImageBlockPublicAccessCallable(
      const DisableImageBlockPublicAccessRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableImageBlockPublicAccess, request);
  }
 
  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);
  }
 
  virtual Model::DisableImageDeprecationOutcome DisableImageDeprecation(const Model::DisableImageDeprecationRequest& request) const;
 
  template <typename DisableImageDeprecationRequestT = Model::DisableImageDeprecationRequest>
  Model::DisableImageDeprecationOutcomeCallable DisableImageDeprecationCallable(const DisableImageDeprecationRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableImageDeprecation, request);
  }
 
  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);
  }
 
  virtual Model::DisableImageDeregistrationProtectionOutcome DisableImageDeregistrationProtection(
      const Model::DisableImageDeregistrationProtectionRequest& request) const;
 
  template <typename DisableImageDeregistrationProtectionRequestT = Model::DisableImageDeregistrationProtectionRequest>
  Model::DisableImageDeregistrationProtectionOutcomeCallable DisableImageDeregistrationProtectionCallable(
      const DisableImageDeregistrationProtectionRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableImageDeregistrationProtection, request);
  }
 
  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);
  }
 
  virtual Model::DisableInstanceSqlHaStandbyDetectionsOutcome DisableInstanceSqlHaStandbyDetections(
      const Model::DisableInstanceSqlHaStandbyDetectionsRequest& request) const;
 
  template <typename DisableInstanceSqlHaStandbyDetectionsRequestT = Model::DisableInstanceSqlHaStandbyDetectionsRequest>
  Model::DisableInstanceSqlHaStandbyDetectionsOutcomeCallable DisableInstanceSqlHaStandbyDetectionsCallable(
      const DisableInstanceSqlHaStandbyDetectionsRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableInstanceSqlHaStandbyDetections, request);
  }
 
  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);
  }
 
  virtual Model::DisableIpamOrganizationAdminAccountOutcome DisableIpamOrganizationAdminAccount(
      const Model::DisableIpamOrganizationAdminAccountRequest& request) const;
 
  template <typename DisableIpamOrganizationAdminAccountRequestT = Model::DisableIpamOrganizationAdminAccountRequest>
  Model::DisableIpamOrganizationAdminAccountOutcomeCallable DisableIpamOrganizationAdminAccountCallable(
      const DisableIpamOrganizationAdminAccountRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableIpamOrganizationAdminAccount, request);
  }
 
  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);
  }
 
  virtual Model::DisableIpamPolicyOutcome DisableIpamPolicy(const Model::DisableIpamPolicyRequest& request) const;
 
  template <typename DisableIpamPolicyRequestT = Model::DisableIpamPolicyRequest>
  Model::DisableIpamPolicyOutcomeCallable DisableIpamPolicyCallable(const DisableIpamPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableIpamPolicy, request);
  }
 
  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);
  }
 
  virtual Model::DisableRouteServerPropagationOutcome DisableRouteServerPropagation(
      const Model::DisableRouteServerPropagationRequest& request) const;
 
  template <typename DisableRouteServerPropagationRequestT = Model::DisableRouteServerPropagationRequest>
  Model::DisableRouteServerPropagationOutcomeCallable DisableRouteServerPropagationCallable(
      const DisableRouteServerPropagationRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableRouteServerPropagation, request);
  }
 
  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);
  }
 
  virtual Model::DisableSerialConsoleAccessOutcome DisableSerialConsoleAccess(
      const Model::DisableSerialConsoleAccessRequest& request = {}) const;
 
  template <typename DisableSerialConsoleAccessRequestT = Model::DisableSerialConsoleAccessRequest>
  Model::DisableSerialConsoleAccessOutcomeCallable DisableSerialConsoleAccessCallable(
      const DisableSerialConsoleAccessRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableSerialConsoleAccess, request);
  }
 
  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);
  }
 
  virtual Model::DisableSnapshotBlockPublicAccessOutcome DisableSnapshotBlockPublicAccess(
      const Model::DisableSnapshotBlockPublicAccessRequest& request = {}) const;
 
  template <typename DisableSnapshotBlockPublicAccessRequestT = Model::DisableSnapshotBlockPublicAccessRequest>
  Model::DisableSnapshotBlockPublicAccessOutcomeCallable DisableSnapshotBlockPublicAccessCallable(
      const DisableSnapshotBlockPublicAccessRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableSnapshotBlockPublicAccess, request);
  }
 
  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);
  }
 
  virtual Model::DisableTransitGatewayRouteTablePropagationOutcome DisableTransitGatewayRouteTablePropagation(
      const Model::DisableTransitGatewayRouteTablePropagationRequest& request) const;
 
  template <typename DisableTransitGatewayRouteTablePropagationRequestT = Model::DisableTransitGatewayRouteTablePropagationRequest>
  Model::DisableTransitGatewayRouteTablePropagationOutcomeCallable DisableTransitGatewayRouteTablePropagationCallable(
      const DisableTransitGatewayRouteTablePropagationRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableTransitGatewayRouteTablePropagation, request);
  }
 
  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);
  }
 
  virtual Model::DisableVgwRoutePropagationOutcome DisableVgwRoutePropagation(
      const Model::DisableVgwRoutePropagationRequest& request) const;
 
  template <typename DisableVgwRoutePropagationRequestT = Model::DisableVgwRoutePropagationRequest>
  Model::DisableVgwRoutePropagationOutcomeCallable DisableVgwRoutePropagationCallable(
      const DisableVgwRoutePropagationRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableVgwRoutePropagation, request);
  }
 
  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);
  }
 
  virtual Model::DisableVpcClassicLinkOutcome DisableVpcClassicLink(const Model::DisableVpcClassicLinkRequest& request) const;
 
  template <typename DisableVpcClassicLinkRequestT = Model::DisableVpcClassicLinkRequest>
  Model::DisableVpcClassicLinkOutcomeCallable DisableVpcClassicLinkCallable(const DisableVpcClassicLinkRequestT& request) const {
    return SubmitCallable(&EC2Client::DisableVpcClassicLink, request);
  }
 
  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);
  }
 
  virtual Model::DisableVpcClassicLinkDnsSupportOutcome DisableVpcClassicLinkDnsSupport(
      const Model::DisableVpcClassicLinkDnsSupportRequest& request = {}) const;
 
  template <typename DisableVpcClassicLinkDnsSupportRequestT = Model::DisableVpcClassicLinkDnsSupportRequest>
  Model::DisableVpcClassicLinkDnsSupportOutcomeCallable DisableVpcClassicLinkDnsSupportCallable(
      const DisableVpcClassicLinkDnsSupportRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisableVpcClassicLinkDnsSupport, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateAddressOutcome DisassociateAddress(const Model::DisassociateAddressRequest& request = {}) const;
 
  template <typename DisassociateAddressRequestT = Model::DisassociateAddressRequest>
  Model::DisassociateAddressOutcomeCallable DisassociateAddressCallable(const DisassociateAddressRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::DisassociateAddress, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateCapacityReservationBillingOwnerOutcome DisassociateCapacityReservationBillingOwner(
      const Model::DisassociateCapacityReservationBillingOwnerRequest& request) const;
 
  template <typename DisassociateCapacityReservationBillingOwnerRequestT = Model::DisassociateCapacityReservationBillingOwnerRequest>
  Model::DisassociateCapacityReservationBillingOwnerOutcomeCallable DisassociateCapacityReservationBillingOwnerCallable(
      const DisassociateCapacityReservationBillingOwnerRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateCapacityReservationBillingOwner, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateClientVpnTargetNetworkOutcome DisassociateClientVpnTargetNetwork(
      const Model::DisassociateClientVpnTargetNetworkRequest& request) const;
 
  template <typename DisassociateClientVpnTargetNetworkRequestT = Model::DisassociateClientVpnTargetNetworkRequest>
  Model::DisassociateClientVpnTargetNetworkOutcomeCallable DisassociateClientVpnTargetNetworkCallable(
      const DisassociateClientVpnTargetNetworkRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateClientVpnTargetNetwork, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateEnclaveCertificateIamRoleOutcome DisassociateEnclaveCertificateIamRole(
      const Model::DisassociateEnclaveCertificateIamRoleRequest& request) const;
 
  template <typename DisassociateEnclaveCertificateIamRoleRequestT = Model::DisassociateEnclaveCertificateIamRoleRequest>
  Model::DisassociateEnclaveCertificateIamRoleOutcomeCallable DisassociateEnclaveCertificateIamRoleCallable(
      const DisassociateEnclaveCertificateIamRoleRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateEnclaveCertificateIamRole, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateIamInstanceProfileOutcome DisassociateIamInstanceProfile(
      const Model::DisassociateIamInstanceProfileRequest& request) const;
 
  template <typename DisassociateIamInstanceProfileRequestT = Model::DisassociateIamInstanceProfileRequest>
  Model::DisassociateIamInstanceProfileOutcomeCallable DisassociateIamInstanceProfileCallable(
      const DisassociateIamInstanceProfileRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateIamInstanceProfile, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateInstanceEventWindowOutcome DisassociateInstanceEventWindow(
      const Model::DisassociateInstanceEventWindowRequest& request) const;
 
  template <typename DisassociateInstanceEventWindowRequestT = Model::DisassociateInstanceEventWindowRequest>
  Model::DisassociateInstanceEventWindowOutcomeCallable DisassociateInstanceEventWindowCallable(
      const DisassociateInstanceEventWindowRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateInstanceEventWindow, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateIpamByoasnOutcome DisassociateIpamByoasn(const Model::DisassociateIpamByoasnRequest& request) const;
 
  template <typename DisassociateIpamByoasnRequestT = Model::DisassociateIpamByoasnRequest>
  Model::DisassociateIpamByoasnOutcomeCallable DisassociateIpamByoasnCallable(const DisassociateIpamByoasnRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateIpamByoasn, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateIpamResourceDiscoveryOutcome DisassociateIpamResourceDiscovery(
      const Model::DisassociateIpamResourceDiscoveryRequest& request) const;
 
  template <typename DisassociateIpamResourceDiscoveryRequestT = Model::DisassociateIpamResourceDiscoveryRequest>
  Model::DisassociateIpamResourceDiscoveryOutcomeCallable DisassociateIpamResourceDiscoveryCallable(
      const DisassociateIpamResourceDiscoveryRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateIpamResourceDiscovery, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateNatGatewayAddressOutcome DisassociateNatGatewayAddress(
      const Model::DisassociateNatGatewayAddressRequest& request) const;
 
  template <typename DisassociateNatGatewayAddressRequestT = Model::DisassociateNatGatewayAddressRequest>
  Model::DisassociateNatGatewayAddressOutcomeCallable DisassociateNatGatewayAddressCallable(
      const DisassociateNatGatewayAddressRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateNatGatewayAddress, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateRouteServerOutcome DisassociateRouteServer(const Model::DisassociateRouteServerRequest& request) const;
 
  template <typename DisassociateRouteServerRequestT = Model::DisassociateRouteServerRequest>
  Model::DisassociateRouteServerOutcomeCallable DisassociateRouteServerCallable(const DisassociateRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateRouteServer, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateRouteTableOutcome DisassociateRouteTable(const Model::DisassociateRouteTableRequest& request) const;
 
  template <typename DisassociateRouteTableRequestT = Model::DisassociateRouteTableRequest>
  Model::DisassociateRouteTableOutcomeCallable DisassociateRouteTableCallable(const DisassociateRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateSecurityGroupVpcOutcome DisassociateSecurityGroupVpc(
      const Model::DisassociateSecurityGroupVpcRequest& request) const;
 
  template <typename DisassociateSecurityGroupVpcRequestT = Model::DisassociateSecurityGroupVpcRequest>
  Model::DisassociateSecurityGroupVpcOutcomeCallable DisassociateSecurityGroupVpcCallable(
      const DisassociateSecurityGroupVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateSecurityGroupVpc, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateSubnetCidrBlockOutcome DisassociateSubnetCidrBlock(
      const Model::DisassociateSubnetCidrBlockRequest& request) const;
 
  template <typename DisassociateSubnetCidrBlockRequestT = Model::DisassociateSubnetCidrBlockRequest>
  Model::DisassociateSubnetCidrBlockOutcomeCallable DisassociateSubnetCidrBlockCallable(
      const DisassociateSubnetCidrBlockRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateSubnetCidrBlock, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateTransitGatewayMulticastDomainOutcome DisassociateTransitGatewayMulticastDomain(
      const Model::DisassociateTransitGatewayMulticastDomainRequest& request) const;
 
  template <typename DisassociateTransitGatewayMulticastDomainRequestT = Model::DisassociateTransitGatewayMulticastDomainRequest>
  Model::DisassociateTransitGatewayMulticastDomainOutcomeCallable DisassociateTransitGatewayMulticastDomainCallable(
      const DisassociateTransitGatewayMulticastDomainRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateTransitGatewayMulticastDomain, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateTransitGatewayPolicyTableOutcome DisassociateTransitGatewayPolicyTable(
      const Model::DisassociateTransitGatewayPolicyTableRequest& request) const;
 
  template <typename DisassociateTransitGatewayPolicyTableRequestT = Model::DisassociateTransitGatewayPolicyTableRequest>
  Model::DisassociateTransitGatewayPolicyTableOutcomeCallable DisassociateTransitGatewayPolicyTableCallable(
      const DisassociateTransitGatewayPolicyTableRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateTransitGatewayPolicyTable, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateTransitGatewayRouteTableOutcome DisassociateTransitGatewayRouteTable(
      const Model::DisassociateTransitGatewayRouteTableRequest& request) const;
 
  template <typename DisassociateTransitGatewayRouteTableRequestT = Model::DisassociateTransitGatewayRouteTableRequest>
  Model::DisassociateTransitGatewayRouteTableOutcomeCallable DisassociateTransitGatewayRouteTableCallable(
      const DisassociateTransitGatewayRouteTableRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateTransitGatewayRouteTable, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateTrunkInterfaceOutcome DisassociateTrunkInterface(
      const Model::DisassociateTrunkInterfaceRequest& request) const;
 
  template <typename DisassociateTrunkInterfaceRequestT = Model::DisassociateTrunkInterfaceRequest>
  Model::DisassociateTrunkInterfaceOutcomeCallable DisassociateTrunkInterfaceCallable(
      const DisassociateTrunkInterfaceRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateTrunkInterface, request);
  }
 
  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);
  }
 
  virtual Model::DisassociateVpcCidrBlockOutcome DisassociateVpcCidrBlock(const Model::DisassociateVpcCidrBlockRequest& request) const;
 
  template <typename DisassociateVpcCidrBlockRequestT = Model::DisassociateVpcCidrBlockRequest>
  Model::DisassociateVpcCidrBlockOutcomeCallable DisassociateVpcCidrBlockCallable(const DisassociateVpcCidrBlockRequestT& request) const {
    return SubmitCallable(&EC2Client::DisassociateVpcCidrBlock, request);
  }
 
  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);
  }
 
  virtual Model::EnableAddressTransferOutcome EnableAddressTransfer(const Model::EnableAddressTransferRequest& request) const;
 
  template <typename EnableAddressTransferRequestT = Model::EnableAddressTransferRequest>
  Model::EnableAddressTransferOutcomeCallable EnableAddressTransferCallable(const EnableAddressTransferRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableAddressTransfer, request);
  }
 
  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);
  }
 
  virtual Model::EnableAllowedImagesSettingsOutcome EnableAllowedImagesSettings(
      const Model::EnableAllowedImagesSettingsRequest& request) const;
 
  template <typename EnableAllowedImagesSettingsRequestT = Model::EnableAllowedImagesSettingsRequest>
  Model::EnableAllowedImagesSettingsOutcomeCallable EnableAllowedImagesSettingsCallable(
      const EnableAllowedImagesSettingsRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableAllowedImagesSettings, request);
  }
 
  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);
  }
 
  virtual Model::EnableAwsNetworkPerformanceMetricSubscriptionOutcome EnableAwsNetworkPerformanceMetricSubscription(
      const Model::EnableAwsNetworkPerformanceMetricSubscriptionRequest& request = {}) const;
 
  template <typename EnableAwsNetworkPerformanceMetricSubscriptionRequestT = Model::EnableAwsNetworkPerformanceMetricSubscriptionRequest>
  Model::EnableAwsNetworkPerformanceMetricSubscriptionOutcomeCallable EnableAwsNetworkPerformanceMetricSubscriptionCallable(
      const EnableAwsNetworkPerformanceMetricSubscriptionRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::EnableAwsNetworkPerformanceMetricSubscription, request);
  }
 
  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);
  }
 
  virtual Model::EnableCapacityManagerOutcome EnableCapacityManager(const Model::EnableCapacityManagerRequest& request = {}) const;
 
  template <typename EnableCapacityManagerRequestT = Model::EnableCapacityManagerRequest>
  Model::EnableCapacityManagerOutcomeCallable EnableCapacityManagerCallable(const EnableCapacityManagerRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::EnableCapacityManager, request);
  }
 
  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);
  }
 
  virtual Model::EnableEbsEncryptionByDefaultOutcome EnableEbsEncryptionByDefault(
      const Model::EnableEbsEncryptionByDefaultRequest& request = {}) const;
 
  template <typename EnableEbsEncryptionByDefaultRequestT = Model::EnableEbsEncryptionByDefaultRequest>
  Model::EnableEbsEncryptionByDefaultOutcomeCallable EnableEbsEncryptionByDefaultCallable(
      const EnableEbsEncryptionByDefaultRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::EnableEbsEncryptionByDefault, request);
  }
 
  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);
  }
 
  virtual Model::EnableFastLaunchOutcome EnableFastLaunch(const Model::EnableFastLaunchRequest& request) const;
 
  template <typename EnableFastLaunchRequestT = Model::EnableFastLaunchRequest>
  Model::EnableFastLaunchOutcomeCallable EnableFastLaunchCallable(const EnableFastLaunchRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableFastLaunch, request);
  }
 
  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);
  }
 
  virtual Model::EnableFastSnapshotRestoresOutcome EnableFastSnapshotRestores(
      const Model::EnableFastSnapshotRestoresRequest& request) const;
 
  template <typename EnableFastSnapshotRestoresRequestT = Model::EnableFastSnapshotRestoresRequest>
  Model::EnableFastSnapshotRestoresOutcomeCallable EnableFastSnapshotRestoresCallable(
      const EnableFastSnapshotRestoresRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableFastSnapshotRestores, request);
  }
 
  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);
  }
 
  virtual Model::EnableImageOutcome EnableImage(const Model::EnableImageRequest& request) const;
 
  template <typename EnableImageRequestT = Model::EnableImageRequest>
  Model::EnableImageOutcomeCallable EnableImageCallable(const EnableImageRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableImage, request);
  }
 
  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);
  }
 
  virtual Model::EnableImageBlockPublicAccessOutcome EnableImageBlockPublicAccess(
      const Model::EnableImageBlockPublicAccessRequest& request) const;
 
  template <typename EnableImageBlockPublicAccessRequestT = Model::EnableImageBlockPublicAccessRequest>
  Model::EnableImageBlockPublicAccessOutcomeCallable EnableImageBlockPublicAccessCallable(
      const EnableImageBlockPublicAccessRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableImageBlockPublicAccess, request);
  }
 
  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);
  }
 
  virtual Model::EnableImageDeprecationOutcome EnableImageDeprecation(const Model::EnableImageDeprecationRequest& request) const;
 
  template <typename EnableImageDeprecationRequestT = Model::EnableImageDeprecationRequest>
  Model::EnableImageDeprecationOutcomeCallable EnableImageDeprecationCallable(const EnableImageDeprecationRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableImageDeprecation, request);
  }
 
  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);
  }
 
  virtual Model::EnableImageDeregistrationProtectionOutcome EnableImageDeregistrationProtection(
      const Model::EnableImageDeregistrationProtectionRequest& request) const;
 
  template <typename EnableImageDeregistrationProtectionRequestT = Model::EnableImageDeregistrationProtectionRequest>
  Model::EnableImageDeregistrationProtectionOutcomeCallable EnableImageDeregistrationProtectionCallable(
      const EnableImageDeregistrationProtectionRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableImageDeregistrationProtection, request);
  }
 
  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);
  }
 
  virtual Model::EnableInstanceSqlHaStandbyDetectionsOutcome EnableInstanceSqlHaStandbyDetections(
      const Model::EnableInstanceSqlHaStandbyDetectionsRequest& request) const;
 
  template <typename EnableInstanceSqlHaStandbyDetectionsRequestT = Model::EnableInstanceSqlHaStandbyDetectionsRequest>
  Model::EnableInstanceSqlHaStandbyDetectionsOutcomeCallable EnableInstanceSqlHaStandbyDetectionsCallable(
      const EnableInstanceSqlHaStandbyDetectionsRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableInstanceSqlHaStandbyDetections, request);
  }
 
  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);
  }
 
  virtual Model::EnableIpamOrganizationAdminAccountOutcome EnableIpamOrganizationAdminAccount(
      const Model::EnableIpamOrganizationAdminAccountRequest& request) const;
 
  template <typename EnableIpamOrganizationAdminAccountRequestT = Model::EnableIpamOrganizationAdminAccountRequest>
  Model::EnableIpamOrganizationAdminAccountOutcomeCallable EnableIpamOrganizationAdminAccountCallable(
      const EnableIpamOrganizationAdminAccountRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableIpamOrganizationAdminAccount, request);
  }
 
  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);
  }
 
  virtual Model::EnableIpamPolicyOutcome EnableIpamPolicy(const Model::EnableIpamPolicyRequest& request) const;
 
  template <typename EnableIpamPolicyRequestT = Model::EnableIpamPolicyRequest>
  Model::EnableIpamPolicyOutcomeCallable EnableIpamPolicyCallable(const EnableIpamPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableIpamPolicy, request);
  }
 
  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);
  }
 
  virtual Model::EnableReachabilityAnalyzerOrganizationSharingOutcome EnableReachabilityAnalyzerOrganizationSharing(
      const Model::EnableReachabilityAnalyzerOrganizationSharingRequest& request = {}) const;
 
  template <typename EnableReachabilityAnalyzerOrganizationSharingRequestT = Model::EnableReachabilityAnalyzerOrganizationSharingRequest>
  Model::EnableReachabilityAnalyzerOrganizationSharingOutcomeCallable EnableReachabilityAnalyzerOrganizationSharingCallable(
      const EnableReachabilityAnalyzerOrganizationSharingRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::EnableReachabilityAnalyzerOrganizationSharing, request);
  }
 
  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);
  }
 
  virtual Model::EnableRouteServerPropagationOutcome EnableRouteServerPropagation(
      const Model::EnableRouteServerPropagationRequest& request) const;
 
  template <typename EnableRouteServerPropagationRequestT = Model::EnableRouteServerPropagationRequest>
  Model::EnableRouteServerPropagationOutcomeCallable EnableRouteServerPropagationCallable(
      const EnableRouteServerPropagationRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableRouteServerPropagation, request);
  }
 
  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);
  }
 
  virtual Model::EnableSerialConsoleAccessOutcome EnableSerialConsoleAccess(
      const Model::EnableSerialConsoleAccessRequest& request = {}) const;
 
  template <typename EnableSerialConsoleAccessRequestT = Model::EnableSerialConsoleAccessRequest>
  Model::EnableSerialConsoleAccessOutcomeCallable EnableSerialConsoleAccessCallable(
      const EnableSerialConsoleAccessRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::EnableSerialConsoleAccess, request);
  }
 
  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);
  }
 
  virtual Model::EnableSnapshotBlockPublicAccessOutcome EnableSnapshotBlockPublicAccess(
      const Model::EnableSnapshotBlockPublicAccessRequest& request) const;
 
  template <typename EnableSnapshotBlockPublicAccessRequestT = Model::EnableSnapshotBlockPublicAccessRequest>
  Model::EnableSnapshotBlockPublicAccessOutcomeCallable EnableSnapshotBlockPublicAccessCallable(
      const EnableSnapshotBlockPublicAccessRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableSnapshotBlockPublicAccess, request);
  }
 
  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);
  }
 
  virtual Model::EnableTransitGatewayRouteTablePropagationOutcome EnableTransitGatewayRouteTablePropagation(
      const Model::EnableTransitGatewayRouteTablePropagationRequest& request) const;
 
  template <typename EnableTransitGatewayRouteTablePropagationRequestT = Model::EnableTransitGatewayRouteTablePropagationRequest>
  Model::EnableTransitGatewayRouteTablePropagationOutcomeCallable EnableTransitGatewayRouteTablePropagationCallable(
      const EnableTransitGatewayRouteTablePropagationRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableTransitGatewayRouteTablePropagation, request);
  }
 
  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);
  }
 
  virtual Model::EnableVgwRoutePropagationOutcome EnableVgwRoutePropagation(const Model::EnableVgwRoutePropagationRequest& request) const;
 
  template <typename EnableVgwRoutePropagationRequestT = Model::EnableVgwRoutePropagationRequest>
  Model::EnableVgwRoutePropagationOutcomeCallable EnableVgwRoutePropagationCallable(
      const EnableVgwRoutePropagationRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableVgwRoutePropagation, request);
  }
 
  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);
  }
 
  virtual Model::EnableVolumeIOOutcome EnableVolumeIO(const Model::EnableVolumeIORequest& request) const;
 
  template <typename EnableVolumeIORequestT = Model::EnableVolumeIORequest>
  Model::EnableVolumeIOOutcomeCallable EnableVolumeIOCallable(const EnableVolumeIORequestT& request) const {
    return SubmitCallable(&EC2Client::EnableVolumeIO, request);
  }
 
  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);
  }
 
  virtual Model::EnableVpcClassicLinkOutcome EnableVpcClassicLink(const Model::EnableVpcClassicLinkRequest& request) const;
 
  template <typename EnableVpcClassicLinkRequestT = Model::EnableVpcClassicLinkRequest>
  Model::EnableVpcClassicLinkOutcomeCallable EnableVpcClassicLinkCallable(const EnableVpcClassicLinkRequestT& request) const {
    return SubmitCallable(&EC2Client::EnableVpcClassicLink, request);
  }
 
  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);
  }
 
  virtual Model::EnableVpcClassicLinkDnsSupportOutcome EnableVpcClassicLinkDnsSupport(
      const Model::EnableVpcClassicLinkDnsSupportRequest& request = {}) const;
 
  template <typename EnableVpcClassicLinkDnsSupportRequestT = Model::EnableVpcClassicLinkDnsSupportRequest>
  Model::EnableVpcClassicLinkDnsSupportOutcomeCallable EnableVpcClassicLinkDnsSupportCallable(
      const EnableVpcClassicLinkDnsSupportRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::EnableVpcClassicLinkDnsSupport, request);
  }
 
  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);
  }
 
  virtual Model::ExportClientVpnClientCertificateRevocationListOutcome ExportClientVpnClientCertificateRevocationList(
      const Model::ExportClientVpnClientCertificateRevocationListRequest& request) const;
 
  template <typename ExportClientVpnClientCertificateRevocationListRequestT = Model::ExportClientVpnClientCertificateRevocationListRequest>
  Model::ExportClientVpnClientCertificateRevocationListOutcomeCallable ExportClientVpnClientCertificateRevocationListCallable(
      const ExportClientVpnClientCertificateRevocationListRequestT& request) const {
    return SubmitCallable(&EC2Client::ExportClientVpnClientCertificateRevocationList, request);
  }
 
  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);
  }
 
  virtual Model::ExportClientVpnClientConfigurationOutcome ExportClientVpnClientConfiguration(
      const Model::ExportClientVpnClientConfigurationRequest& request) const;
 
  template <typename ExportClientVpnClientConfigurationRequestT = Model::ExportClientVpnClientConfigurationRequest>
  Model::ExportClientVpnClientConfigurationOutcomeCallable ExportClientVpnClientConfigurationCallable(
      const ExportClientVpnClientConfigurationRequestT& request) const {
    return SubmitCallable(&EC2Client::ExportClientVpnClientConfiguration, request);
  }
 
  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);
  }
 
  virtual Model::ExportImageOutcome ExportImage(const Model::ExportImageRequest& request) const;
 
  template <typename ExportImageRequestT = Model::ExportImageRequest>
  Model::ExportImageOutcomeCallable ExportImageCallable(const ExportImageRequestT& request) const {
    return SubmitCallable(&EC2Client::ExportImage, request);
  }
 
  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);
  }
 
  virtual Model::ExportTransitGatewayRoutesOutcome ExportTransitGatewayRoutes(
      const Model::ExportTransitGatewayRoutesRequest& request) const;
 
  template <typename ExportTransitGatewayRoutesRequestT = Model::ExportTransitGatewayRoutesRequest>
  Model::ExportTransitGatewayRoutesOutcomeCallable ExportTransitGatewayRoutesCallable(
      const ExportTransitGatewayRoutesRequestT& request) const {
    return SubmitCallable(&EC2Client::ExportTransitGatewayRoutes, request);
  }
 
  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);
  }
 
  virtual Model::ExportVerifiedAccessInstanceClientConfigurationOutcome ExportVerifiedAccessInstanceClientConfiguration(
      const Model::ExportVerifiedAccessInstanceClientConfigurationRequest& request) const;
 
  template <
      typename ExportVerifiedAccessInstanceClientConfigurationRequestT = Model::ExportVerifiedAccessInstanceClientConfigurationRequest>
  Model::ExportVerifiedAccessInstanceClientConfigurationOutcomeCallable ExportVerifiedAccessInstanceClientConfigurationCallable(
      const ExportVerifiedAccessInstanceClientConfigurationRequestT& request) const {
    return SubmitCallable(&EC2Client::ExportVerifiedAccessInstanceClientConfiguration, request);
  }
 
  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);
  }
 
  virtual Model::GetActiveVpnTunnelStatusOutcome GetActiveVpnTunnelStatus(const Model::GetActiveVpnTunnelStatusRequest& request) const;
 
  template <typename GetActiveVpnTunnelStatusRequestT = Model::GetActiveVpnTunnelStatusRequest>
  Model::GetActiveVpnTunnelStatusOutcomeCallable GetActiveVpnTunnelStatusCallable(const GetActiveVpnTunnelStatusRequestT& request) const {
    return SubmitCallable(&EC2Client::GetActiveVpnTunnelStatus, request);
  }
 
  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);
  }
 
  virtual Model::GetAllowedImagesSettingsOutcome GetAllowedImagesSettings(const Model::GetAllowedImagesSettingsRequest& request = {}) const;
 
  template <typename GetAllowedImagesSettingsRequestT = Model::GetAllowedImagesSettingsRequest>
  Model::GetAllowedImagesSettingsOutcomeCallable GetAllowedImagesSettingsCallable(
      const GetAllowedImagesSettingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetAllowedImagesSettings, request);
  }
 
  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);
  }
 
  virtual Model::GetAssociatedEnclaveCertificateIamRolesOutcome GetAssociatedEnclaveCertificateIamRoles(
      const Model::GetAssociatedEnclaveCertificateIamRolesRequest& request) const;
 
  template <typename GetAssociatedEnclaveCertificateIamRolesRequestT = Model::GetAssociatedEnclaveCertificateIamRolesRequest>
  Model::GetAssociatedEnclaveCertificateIamRolesOutcomeCallable GetAssociatedEnclaveCertificateIamRolesCallable(
      const GetAssociatedEnclaveCertificateIamRolesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetAssociatedEnclaveCertificateIamRoles, request);
  }
 
  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);
  }
 
  virtual Model::GetAssociatedIpv6PoolCidrsOutcome GetAssociatedIpv6PoolCidrs(
      const Model::GetAssociatedIpv6PoolCidrsRequest& request) const;
 
  template <typename GetAssociatedIpv6PoolCidrsRequestT = Model::GetAssociatedIpv6PoolCidrsRequest>
  Model::GetAssociatedIpv6PoolCidrsOutcomeCallable GetAssociatedIpv6PoolCidrsCallable(
      const GetAssociatedIpv6PoolCidrsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetAssociatedIpv6PoolCidrs, request);
  }
 
  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);
  }
 
  virtual Model::GetAwsNetworkPerformanceDataOutcome GetAwsNetworkPerformanceData(
      const Model::GetAwsNetworkPerformanceDataRequest& request = {}) const;
 
  template <typename GetAwsNetworkPerformanceDataRequestT = Model::GetAwsNetworkPerformanceDataRequest>
  Model::GetAwsNetworkPerformanceDataOutcomeCallable GetAwsNetworkPerformanceDataCallable(
      const GetAwsNetworkPerformanceDataRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetAwsNetworkPerformanceData, request);
  }
 
  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);
  }
 
  virtual Model::GetCapacityManagerAttributesOutcome GetCapacityManagerAttributes(
      const Model::GetCapacityManagerAttributesRequest& request = {}) const;
 
  template <typename GetCapacityManagerAttributesRequestT = Model::GetCapacityManagerAttributesRequest>
  Model::GetCapacityManagerAttributesOutcomeCallable GetCapacityManagerAttributesCallable(
      const GetCapacityManagerAttributesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetCapacityManagerAttributes, request);
  }
 
  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);
  }
 
  virtual Model::GetCapacityManagerMetricDataOutcome GetCapacityManagerMetricData(
      const Model::GetCapacityManagerMetricDataRequest& request) const;
 
  template <typename GetCapacityManagerMetricDataRequestT = Model::GetCapacityManagerMetricDataRequest>
  Model::GetCapacityManagerMetricDataOutcomeCallable GetCapacityManagerMetricDataCallable(
      const GetCapacityManagerMetricDataRequestT& request) const {
    return SubmitCallable(&EC2Client::GetCapacityManagerMetricData, request);
  }
 
  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);
  }
 
  virtual Model::GetCapacityManagerMetricDimensionsOutcome GetCapacityManagerMetricDimensions(
      const Model::GetCapacityManagerMetricDimensionsRequest& request) const;
 
  template <typename GetCapacityManagerMetricDimensionsRequestT = Model::GetCapacityManagerMetricDimensionsRequest>
  Model::GetCapacityManagerMetricDimensionsOutcomeCallable GetCapacityManagerMetricDimensionsCallable(
      const GetCapacityManagerMetricDimensionsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetCapacityManagerMetricDimensions, request);
  }
 
  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);
  }
 
  virtual Model::GetCapacityManagerMonitoredTagKeysOutcome GetCapacityManagerMonitoredTagKeys(
      const Model::GetCapacityManagerMonitoredTagKeysRequest& request = {}) const;
 
  template <typename GetCapacityManagerMonitoredTagKeysRequestT = Model::GetCapacityManagerMonitoredTagKeysRequest>
  Model::GetCapacityManagerMonitoredTagKeysOutcomeCallable GetCapacityManagerMonitoredTagKeysCallable(
      const GetCapacityManagerMonitoredTagKeysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetCapacityManagerMonitoredTagKeys, request);
  }
 
  template <typename GetCapacityManagerMonitoredTagKeysRequestT = Model::GetCapacityManagerMonitoredTagKeysRequest>
  void GetCapacityManagerMonitoredTagKeysAsync(const GetCapacityManagerMonitoredTagKeysResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                               const GetCapacityManagerMonitoredTagKeysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetCapacityManagerMonitoredTagKeys, request, handler, context);
  }
 
  virtual Model::GetCapacityReservationUsageOutcome GetCapacityReservationUsage(
      const Model::GetCapacityReservationUsageRequest& request) const;
 
  template <typename GetCapacityReservationUsageRequestT = Model::GetCapacityReservationUsageRequest>
  Model::GetCapacityReservationUsageOutcomeCallable GetCapacityReservationUsageCallable(
      const GetCapacityReservationUsageRequestT& request) const {
    return SubmitCallable(&EC2Client::GetCapacityReservationUsage, request);
  }
 
  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);
  }
 
  virtual Model::GetCoipPoolUsageOutcome GetCoipPoolUsage(const Model::GetCoipPoolUsageRequest& request) const;
 
  template <typename GetCoipPoolUsageRequestT = Model::GetCoipPoolUsageRequest>
  Model::GetCoipPoolUsageOutcomeCallable GetCoipPoolUsageCallable(const GetCoipPoolUsageRequestT& request) const {
    return SubmitCallable(&EC2Client::GetCoipPoolUsage, request);
  }
 
  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);
  }
 
  virtual Model::GetConsoleOutputOutcome GetConsoleOutput(const Model::GetConsoleOutputRequest& request) const;
 
  template <typename GetConsoleOutputRequestT = Model::GetConsoleOutputRequest>
  Model::GetConsoleOutputOutcomeCallable GetConsoleOutputCallable(const GetConsoleOutputRequestT& request) const {
    return SubmitCallable(&EC2Client::GetConsoleOutput, request);
  }
 
  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);
  }
 
  virtual Model::GetConsoleScreenshotOutcome GetConsoleScreenshot(const Model::GetConsoleScreenshotRequest& request) const;
 
  template <typename GetConsoleScreenshotRequestT = Model::GetConsoleScreenshotRequest>
  Model::GetConsoleScreenshotOutcomeCallable GetConsoleScreenshotCallable(const GetConsoleScreenshotRequestT& request) const {
    return SubmitCallable(&EC2Client::GetConsoleScreenshot, request);
  }
 
  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);
  }
 
  virtual Model::GetDeclarativePoliciesReportSummaryOutcome GetDeclarativePoliciesReportSummary(
      const Model::GetDeclarativePoliciesReportSummaryRequest& request) const;
 
  template <typename GetDeclarativePoliciesReportSummaryRequestT = Model::GetDeclarativePoliciesReportSummaryRequest>
  Model::GetDeclarativePoliciesReportSummaryOutcomeCallable GetDeclarativePoliciesReportSummaryCallable(
      const GetDeclarativePoliciesReportSummaryRequestT& request) const {
    return SubmitCallable(&EC2Client::GetDeclarativePoliciesReportSummary, request);
  }
 
  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);
  }
 
  virtual Model::GetDefaultCreditSpecificationOutcome GetDefaultCreditSpecification(
      const Model::GetDefaultCreditSpecificationRequest& request) const;
 
  template <typename GetDefaultCreditSpecificationRequestT = Model::GetDefaultCreditSpecificationRequest>
  Model::GetDefaultCreditSpecificationOutcomeCallable GetDefaultCreditSpecificationCallable(
      const GetDefaultCreditSpecificationRequestT& request) const {
    return SubmitCallable(&EC2Client::GetDefaultCreditSpecification, request);
  }
 
  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);
  }
 
  virtual Model::GetEbsDefaultKmsKeyIdOutcome GetEbsDefaultKmsKeyId(const Model::GetEbsDefaultKmsKeyIdRequest& request = {}) const;
 
  template <typename GetEbsDefaultKmsKeyIdRequestT = Model::GetEbsDefaultKmsKeyIdRequest>
  Model::GetEbsDefaultKmsKeyIdOutcomeCallable GetEbsDefaultKmsKeyIdCallable(const GetEbsDefaultKmsKeyIdRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetEbsDefaultKmsKeyId, request);
  }
 
  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);
  }
 
  virtual Model::GetEbsEncryptionByDefaultOutcome GetEbsEncryptionByDefault(
      const Model::GetEbsEncryptionByDefaultRequest& request = {}) const;
 
  template <typename GetEbsEncryptionByDefaultRequestT = Model::GetEbsEncryptionByDefaultRequest>
  Model::GetEbsEncryptionByDefaultOutcomeCallable GetEbsEncryptionByDefaultCallable(
      const GetEbsEncryptionByDefaultRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetEbsEncryptionByDefault, request);
  }
 
  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);
  }
 
  virtual Model::GetEnabledIpamPolicyOutcome GetEnabledIpamPolicy(const Model::GetEnabledIpamPolicyRequest& request = {}) const;
 
  template <typename GetEnabledIpamPolicyRequestT = Model::GetEnabledIpamPolicyRequest>
  Model::GetEnabledIpamPolicyOutcomeCallable GetEnabledIpamPolicyCallable(const GetEnabledIpamPolicyRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetEnabledIpamPolicy, request);
  }
 
  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);
  }
 
  virtual Model::GetFlowLogsIntegrationTemplateOutcome GetFlowLogsIntegrationTemplate(
      const Model::GetFlowLogsIntegrationTemplateRequest& request) const;
 
  template <typename GetFlowLogsIntegrationTemplateRequestT = Model::GetFlowLogsIntegrationTemplateRequest>
  Model::GetFlowLogsIntegrationTemplateOutcomeCallable GetFlowLogsIntegrationTemplateCallable(
      const GetFlowLogsIntegrationTemplateRequestT& request) const {
    return SubmitCallable(&EC2Client::GetFlowLogsIntegrationTemplate, request);
  }
 
  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);
  }
 
  virtual Model::GetGroupsForCapacityReservationOutcome GetGroupsForCapacityReservation(
      const Model::GetGroupsForCapacityReservationRequest& request) const;
 
  template <typename GetGroupsForCapacityReservationRequestT = Model::GetGroupsForCapacityReservationRequest>
  Model::GetGroupsForCapacityReservationOutcomeCallable GetGroupsForCapacityReservationCallable(
      const GetGroupsForCapacityReservationRequestT& request) const {
    return SubmitCallable(&EC2Client::GetGroupsForCapacityReservation, request);
  }
 
  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);
  }
 
  virtual Model::GetHostReservationPurchasePreviewOutcome GetHostReservationPurchasePreview(
      const Model::GetHostReservationPurchasePreviewRequest& request) const;
 
  template <typename GetHostReservationPurchasePreviewRequestT = Model::GetHostReservationPurchasePreviewRequest>
  Model::GetHostReservationPurchasePreviewOutcomeCallable GetHostReservationPurchasePreviewCallable(
      const GetHostReservationPurchasePreviewRequestT& request) const {
    return SubmitCallable(&EC2Client::GetHostReservationPurchasePreview, request);
  }
 
  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);
  }
 
  virtual Model::GetImageAncestryOutcome GetImageAncestry(const Model::GetImageAncestryRequest& request) const;
 
  template <typename GetImageAncestryRequestT = Model::GetImageAncestryRequest>
  Model::GetImageAncestryOutcomeCallable GetImageAncestryCallable(const GetImageAncestryRequestT& request) const {
    return SubmitCallable(&EC2Client::GetImageAncestry, request);
  }
 
  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);
  }
 
  virtual Model::GetImageBlockPublicAccessStateOutcome GetImageBlockPublicAccessState(
      const Model::GetImageBlockPublicAccessStateRequest& request = {}) const;
 
  template <typename GetImageBlockPublicAccessStateRequestT = Model::GetImageBlockPublicAccessStateRequest>
  Model::GetImageBlockPublicAccessStateOutcomeCallable GetImageBlockPublicAccessStateCallable(
      const GetImageBlockPublicAccessStateRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetImageBlockPublicAccessState, request);
  }
 
  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);
  }
 
  virtual Model::GetInstanceMetadataDefaultsOutcome GetInstanceMetadataDefaults(
      const Model::GetInstanceMetadataDefaultsRequest& request = {}) const;
 
  template <typename GetInstanceMetadataDefaultsRequestT = Model::GetInstanceMetadataDefaultsRequest>
  Model::GetInstanceMetadataDefaultsOutcomeCallable GetInstanceMetadataDefaultsCallable(
      const GetInstanceMetadataDefaultsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetInstanceMetadataDefaults, request);
  }
 
  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);
  }
 
  virtual Model::GetInstanceTpmEkPubOutcome GetInstanceTpmEkPub(const Model::GetInstanceTpmEkPubRequest& request) const;
 
  template <typename GetInstanceTpmEkPubRequestT = Model::GetInstanceTpmEkPubRequest>
  Model::GetInstanceTpmEkPubOutcomeCallable GetInstanceTpmEkPubCallable(const GetInstanceTpmEkPubRequestT& request) const {
    return SubmitCallable(&EC2Client::GetInstanceTpmEkPub, request);
  }
 
  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);
  }
 
  virtual Model::GetInstanceTypesFromInstanceRequirementsOutcome GetInstanceTypesFromInstanceRequirements(
      const Model::GetInstanceTypesFromInstanceRequirementsRequest& request) const;
 
  template <typename GetInstanceTypesFromInstanceRequirementsRequestT = Model::GetInstanceTypesFromInstanceRequirementsRequest>
  Model::GetInstanceTypesFromInstanceRequirementsOutcomeCallable GetInstanceTypesFromInstanceRequirementsCallable(
      const GetInstanceTypesFromInstanceRequirementsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetInstanceTypesFromInstanceRequirements, request);
  }
 
  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);
  }
 
  virtual Model::GetInstanceUefiDataOutcome GetInstanceUefiData(const Model::GetInstanceUefiDataRequest& request) const;
 
  template <typename GetInstanceUefiDataRequestT = Model::GetInstanceUefiDataRequest>
  Model::GetInstanceUefiDataOutcomeCallable GetInstanceUefiDataCallable(const GetInstanceUefiDataRequestT& request) const {
    return SubmitCallable(&EC2Client::GetInstanceUefiData, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamAddressHistoryOutcome GetIpamAddressHistory(const Model::GetIpamAddressHistoryRequest& request) const;
 
  template <typename GetIpamAddressHistoryRequestT = Model::GetIpamAddressHistoryRequest>
  Model::GetIpamAddressHistoryOutcomeCallable GetIpamAddressHistoryCallable(const GetIpamAddressHistoryRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamAddressHistory, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamDiscoveredAccountsOutcome GetIpamDiscoveredAccounts(const Model::GetIpamDiscoveredAccountsRequest& request) const;
 
  template <typename GetIpamDiscoveredAccountsRequestT = Model::GetIpamDiscoveredAccountsRequest>
  Model::GetIpamDiscoveredAccountsOutcomeCallable GetIpamDiscoveredAccountsCallable(
      const GetIpamDiscoveredAccountsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamDiscoveredAccounts, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamDiscoveredPublicAddressesOutcome GetIpamDiscoveredPublicAddresses(
      const Model::GetIpamDiscoveredPublicAddressesRequest& request) const;
 
  template <typename GetIpamDiscoveredPublicAddressesRequestT = Model::GetIpamDiscoveredPublicAddressesRequest>
  Model::GetIpamDiscoveredPublicAddressesOutcomeCallable GetIpamDiscoveredPublicAddressesCallable(
      const GetIpamDiscoveredPublicAddressesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamDiscoveredPublicAddresses, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamDiscoveredResourceCidrsOutcome GetIpamDiscoveredResourceCidrs(
      const Model::GetIpamDiscoveredResourceCidrsRequest& request) const;
 
  template <typename GetIpamDiscoveredResourceCidrsRequestT = Model::GetIpamDiscoveredResourceCidrsRequest>
  Model::GetIpamDiscoveredResourceCidrsOutcomeCallable GetIpamDiscoveredResourceCidrsCallable(
      const GetIpamDiscoveredResourceCidrsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamDiscoveredResourceCidrs, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamPolicyAllocationRulesOutcome GetIpamPolicyAllocationRules(
      const Model::GetIpamPolicyAllocationRulesRequest& request) const;
 
  template <typename GetIpamPolicyAllocationRulesRequestT = Model::GetIpamPolicyAllocationRulesRequest>
  Model::GetIpamPolicyAllocationRulesOutcomeCallable GetIpamPolicyAllocationRulesCallable(
      const GetIpamPolicyAllocationRulesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPolicyAllocationRules, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamPolicyOrganizationTargetsOutcome GetIpamPolicyOrganizationTargets(
      const Model::GetIpamPolicyOrganizationTargetsRequest& request) const;
 
  template <typename GetIpamPolicyOrganizationTargetsRequestT = Model::GetIpamPolicyOrganizationTargetsRequest>
  Model::GetIpamPolicyOrganizationTargetsOutcomeCallable GetIpamPolicyOrganizationTargetsCallable(
      const GetIpamPolicyOrganizationTargetsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPolicyOrganizationTargets, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamPoolAllocationsOutcome GetIpamPoolAllocations(const Model::GetIpamPoolAllocationsRequest& request) const;
 
  template <typename GetIpamPoolAllocationsRequestT = Model::GetIpamPoolAllocationsRequest>
  Model::GetIpamPoolAllocationsOutcomeCallable GetIpamPoolAllocationsCallable(const GetIpamPoolAllocationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPoolAllocations, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamPoolCidrsOutcome GetIpamPoolCidrs(const Model::GetIpamPoolCidrsRequest& request) const;
 
  template <typename GetIpamPoolCidrsRequestT = Model::GetIpamPoolCidrsRequest>
  Model::GetIpamPoolCidrsOutcomeCallable GetIpamPoolCidrsCallable(const GetIpamPoolCidrsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPoolCidrs, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamPrefixListResolverRulesOutcome GetIpamPrefixListResolverRules(
      const Model::GetIpamPrefixListResolverRulesRequest& request) const;
 
  template <typename GetIpamPrefixListResolverRulesRequestT = Model::GetIpamPrefixListResolverRulesRequest>
  Model::GetIpamPrefixListResolverRulesOutcomeCallable GetIpamPrefixListResolverRulesCallable(
      const GetIpamPrefixListResolverRulesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPrefixListResolverRules, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamPrefixListResolverVersionEntriesOutcome GetIpamPrefixListResolverVersionEntries(
      const Model::GetIpamPrefixListResolverVersionEntriesRequest& request) const;
 
  template <typename GetIpamPrefixListResolverVersionEntriesRequestT = Model::GetIpamPrefixListResolverVersionEntriesRequest>
  Model::GetIpamPrefixListResolverVersionEntriesOutcomeCallable GetIpamPrefixListResolverVersionEntriesCallable(
      const GetIpamPrefixListResolverVersionEntriesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPrefixListResolverVersionEntries, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamPrefixListResolverVersionsOutcome GetIpamPrefixListResolverVersions(
      const Model::GetIpamPrefixListResolverVersionsRequest& request) const;
 
  template <typename GetIpamPrefixListResolverVersionsRequestT = Model::GetIpamPrefixListResolverVersionsRequest>
  Model::GetIpamPrefixListResolverVersionsOutcomeCallable GetIpamPrefixListResolverVersionsCallable(
      const GetIpamPrefixListResolverVersionsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamPrefixListResolverVersions, request);
  }
 
  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);
  }
 
  virtual Model::GetIpamResourceCidrsOutcome GetIpamResourceCidrs(const Model::GetIpamResourceCidrsRequest& request) const;
 
  template <typename GetIpamResourceCidrsRequestT = Model::GetIpamResourceCidrsRequest>
  Model::GetIpamResourceCidrsOutcomeCallable GetIpamResourceCidrsCallable(const GetIpamResourceCidrsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetIpamResourceCidrs, request);
  }
 
  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);
  }
 
  virtual Model::GetLaunchTemplateDataOutcome GetLaunchTemplateData(const Model::GetLaunchTemplateDataRequest& request) const;
 
  template <typename GetLaunchTemplateDataRequestT = Model::GetLaunchTemplateDataRequest>
  Model::GetLaunchTemplateDataOutcomeCallable GetLaunchTemplateDataCallable(const GetLaunchTemplateDataRequestT& request) const {
    return SubmitCallable(&EC2Client::GetLaunchTemplateData, request);
  }
 
  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);
  }
 
  virtual Model::GetManagedPrefixListAssociationsOutcome GetManagedPrefixListAssociations(
      const Model::GetManagedPrefixListAssociationsRequest& request) const;
 
  template <typename GetManagedPrefixListAssociationsRequestT = Model::GetManagedPrefixListAssociationsRequest>
  Model::GetManagedPrefixListAssociationsOutcomeCallable GetManagedPrefixListAssociationsCallable(
      const GetManagedPrefixListAssociationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetManagedPrefixListAssociations, request);
  }
 
  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);
  }
 
  virtual Model::GetManagedPrefixListEntriesOutcome GetManagedPrefixListEntries(
      const Model::GetManagedPrefixListEntriesRequest& request) const;
 
  template <typename GetManagedPrefixListEntriesRequestT = Model::GetManagedPrefixListEntriesRequest>
  Model::GetManagedPrefixListEntriesOutcomeCallable GetManagedPrefixListEntriesCallable(
      const GetManagedPrefixListEntriesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetManagedPrefixListEntries, request);
  }
 
  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);
  }
 
  virtual Model::GetManagedResourceVisibilityOutcome GetManagedResourceVisibility(
      const Model::GetManagedResourceVisibilityRequest& request = {}) const;
 
  template <typename GetManagedResourceVisibilityRequestT = Model::GetManagedResourceVisibilityRequest>
  Model::GetManagedResourceVisibilityOutcomeCallable GetManagedResourceVisibilityCallable(
      const GetManagedResourceVisibilityRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetManagedResourceVisibility, request);
  }
 
  template <typename GetManagedResourceVisibilityRequestT = Model::GetManagedResourceVisibilityRequest>
  void GetManagedResourceVisibilityAsync(const GetManagedResourceVisibilityResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetManagedResourceVisibilityRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::GetManagedResourceVisibility, request, handler, context);
  }
 
  virtual Model::GetNetworkInsightsAccessScopeAnalysisFindingsOutcome GetNetworkInsightsAccessScopeAnalysisFindings(
      const Model::GetNetworkInsightsAccessScopeAnalysisFindingsRequest& request) const;
 
  template <typename GetNetworkInsightsAccessScopeAnalysisFindingsRequestT = Model::GetNetworkInsightsAccessScopeAnalysisFindingsRequest>
  Model::GetNetworkInsightsAccessScopeAnalysisFindingsOutcomeCallable GetNetworkInsightsAccessScopeAnalysisFindingsCallable(
      const GetNetworkInsightsAccessScopeAnalysisFindingsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetNetworkInsightsAccessScopeAnalysisFindings, request);
  }
 
  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);
  }
 
  virtual Model::GetNetworkInsightsAccessScopeContentOutcome GetNetworkInsightsAccessScopeContent(
      const Model::GetNetworkInsightsAccessScopeContentRequest& request) const;
 
  template <typename GetNetworkInsightsAccessScopeContentRequestT = Model::GetNetworkInsightsAccessScopeContentRequest>
  Model::GetNetworkInsightsAccessScopeContentOutcomeCallable GetNetworkInsightsAccessScopeContentCallable(
      const GetNetworkInsightsAccessScopeContentRequestT& request) const {
    return SubmitCallable(&EC2Client::GetNetworkInsightsAccessScopeContent, request);
  }
 
  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);
  }
 
  virtual Model::GetPasswordDataOutcome GetPasswordData(const Model::GetPasswordDataRequest& request) const;
 
  template <typename GetPasswordDataRequestT = Model::GetPasswordDataRequest>
  Model::GetPasswordDataOutcomeCallable GetPasswordDataCallable(const GetPasswordDataRequestT& request) const {
    return SubmitCallable(&EC2Client::GetPasswordData, request);
  }
 
  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);
  }
 
  virtual Model::GetReservedInstancesExchangeQuoteOutcome GetReservedInstancesExchangeQuote(
      const Model::GetReservedInstancesExchangeQuoteRequest& request) const;
 
  template <typename GetReservedInstancesExchangeQuoteRequestT = Model::GetReservedInstancesExchangeQuoteRequest>
  Model::GetReservedInstancesExchangeQuoteOutcomeCallable GetReservedInstancesExchangeQuoteCallable(
      const GetReservedInstancesExchangeQuoteRequestT& request) const {
    return SubmitCallable(&EC2Client::GetReservedInstancesExchangeQuote, request);
  }
 
  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);
  }
 
  virtual Model::GetRouteServerAssociationsOutcome GetRouteServerAssociations(
      const Model::GetRouteServerAssociationsRequest& request) const;
 
  template <typename GetRouteServerAssociationsRequestT = Model::GetRouteServerAssociationsRequest>
  Model::GetRouteServerAssociationsOutcomeCallable GetRouteServerAssociationsCallable(
      const GetRouteServerAssociationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetRouteServerAssociations, request);
  }
 
  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);
  }
 
  virtual Model::GetRouteServerPropagationsOutcome GetRouteServerPropagations(
      const Model::GetRouteServerPropagationsRequest& request) const;
 
  template <typename GetRouteServerPropagationsRequestT = Model::GetRouteServerPropagationsRequest>
  Model::GetRouteServerPropagationsOutcomeCallable GetRouteServerPropagationsCallable(
      const GetRouteServerPropagationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetRouteServerPropagations, request);
  }
 
  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);
  }
 
  virtual Model::GetRouteServerRoutingDatabaseOutcome GetRouteServerRoutingDatabase(
      const Model::GetRouteServerRoutingDatabaseRequest& request) const;
 
  template <typename GetRouteServerRoutingDatabaseRequestT = Model::GetRouteServerRoutingDatabaseRequest>
  Model::GetRouteServerRoutingDatabaseOutcomeCallable GetRouteServerRoutingDatabaseCallable(
      const GetRouteServerRoutingDatabaseRequestT& request) const {
    return SubmitCallable(&EC2Client::GetRouteServerRoutingDatabase, request);
  }
 
  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);
  }
 
  virtual Model::GetSecurityGroupsForVpcOutcome GetSecurityGroupsForVpc(const Model::GetSecurityGroupsForVpcRequest& request) const;
 
  template <typename GetSecurityGroupsForVpcRequestT = Model::GetSecurityGroupsForVpcRequest>
  Model::GetSecurityGroupsForVpcOutcomeCallable GetSecurityGroupsForVpcCallable(const GetSecurityGroupsForVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::GetSecurityGroupsForVpc, request);
  }
 
  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);
  }
 
  virtual Model::GetSerialConsoleAccessStatusOutcome GetSerialConsoleAccessStatus(
      const Model::GetSerialConsoleAccessStatusRequest& request = {}) const;
 
  template <typename GetSerialConsoleAccessStatusRequestT = Model::GetSerialConsoleAccessStatusRequest>
  Model::GetSerialConsoleAccessStatusOutcomeCallable GetSerialConsoleAccessStatusCallable(
      const GetSerialConsoleAccessStatusRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetSerialConsoleAccessStatus, request);
  }
 
  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);
  }
 
  virtual Model::GetSnapshotBlockPublicAccessStateOutcome GetSnapshotBlockPublicAccessState(
      const Model::GetSnapshotBlockPublicAccessStateRequest& request = {}) const;
 
  template <typename GetSnapshotBlockPublicAccessStateRequestT = Model::GetSnapshotBlockPublicAccessStateRequest>
  Model::GetSnapshotBlockPublicAccessStateOutcomeCallable GetSnapshotBlockPublicAccessStateCallable(
      const GetSnapshotBlockPublicAccessStateRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetSnapshotBlockPublicAccessState, request);
  }
 
  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);
  }
 
  virtual Model::GetSpotPlacementScoresOutcome GetSpotPlacementScores(const Model::GetSpotPlacementScoresRequest& request) const;
 
  template <typename GetSpotPlacementScoresRequestT = Model::GetSpotPlacementScoresRequest>
  Model::GetSpotPlacementScoresOutcomeCallable GetSpotPlacementScoresCallable(const GetSpotPlacementScoresRequestT& request) const {
    return SubmitCallable(&EC2Client::GetSpotPlacementScores, request);
  }
 
  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);
  }
 
  virtual Model::GetSubnetCidrReservationsOutcome GetSubnetCidrReservations(const Model::GetSubnetCidrReservationsRequest& request) const;
 
  template <typename GetSubnetCidrReservationsRequestT = Model::GetSubnetCidrReservationsRequest>
  Model::GetSubnetCidrReservationsOutcomeCallable GetSubnetCidrReservationsCallable(
      const GetSubnetCidrReservationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetSubnetCidrReservations, request);
  }
 
  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);
  }
 
  virtual Model::GetTransitGatewayAttachmentPropagationsOutcome GetTransitGatewayAttachmentPropagations(
      const Model::GetTransitGatewayAttachmentPropagationsRequest& request) const;
 
  template <typename GetTransitGatewayAttachmentPropagationsRequestT = Model::GetTransitGatewayAttachmentPropagationsRequest>
  Model::GetTransitGatewayAttachmentPropagationsOutcomeCallable GetTransitGatewayAttachmentPropagationsCallable(
      const GetTransitGatewayAttachmentPropagationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetTransitGatewayAttachmentPropagations, request);
  }
 
  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);
  }
 
  virtual Model::GetTransitGatewayMeteringPolicyEntriesOutcome GetTransitGatewayMeteringPolicyEntries(
      const Model::GetTransitGatewayMeteringPolicyEntriesRequest& request) const;
 
  template <typename GetTransitGatewayMeteringPolicyEntriesRequestT = Model::GetTransitGatewayMeteringPolicyEntriesRequest>
  Model::GetTransitGatewayMeteringPolicyEntriesOutcomeCallable GetTransitGatewayMeteringPolicyEntriesCallable(
      const GetTransitGatewayMeteringPolicyEntriesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetTransitGatewayMeteringPolicyEntries, request);
  }
 
  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);
  }
 
  virtual Model::GetTransitGatewayMulticastDomainAssociationsOutcome GetTransitGatewayMulticastDomainAssociations(
      const Model::GetTransitGatewayMulticastDomainAssociationsRequest& request) const;
 
  template <typename GetTransitGatewayMulticastDomainAssociationsRequestT = Model::GetTransitGatewayMulticastDomainAssociationsRequest>
  Model::GetTransitGatewayMulticastDomainAssociationsOutcomeCallable GetTransitGatewayMulticastDomainAssociationsCallable(
      const GetTransitGatewayMulticastDomainAssociationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetTransitGatewayMulticastDomainAssociations, request);
  }
 
  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);
  }
 
  virtual Model::GetTransitGatewayPolicyTableAssociationsOutcome GetTransitGatewayPolicyTableAssociations(
      const Model::GetTransitGatewayPolicyTableAssociationsRequest& request) const;
 
  template <typename GetTransitGatewayPolicyTableAssociationsRequestT = Model::GetTransitGatewayPolicyTableAssociationsRequest>
  Model::GetTransitGatewayPolicyTableAssociationsOutcomeCallable GetTransitGatewayPolicyTableAssociationsCallable(
      const GetTransitGatewayPolicyTableAssociationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetTransitGatewayPolicyTableAssociations, request);
  }
 
  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);
  }
 
  virtual Model::GetTransitGatewayPolicyTableEntriesOutcome GetTransitGatewayPolicyTableEntries(
      const Model::GetTransitGatewayPolicyTableEntriesRequest& request) const;
 
  template <typename GetTransitGatewayPolicyTableEntriesRequestT = Model::GetTransitGatewayPolicyTableEntriesRequest>
  Model::GetTransitGatewayPolicyTableEntriesOutcomeCallable GetTransitGatewayPolicyTableEntriesCallable(
      const GetTransitGatewayPolicyTableEntriesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetTransitGatewayPolicyTableEntries, request);
  }
 
  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);
  }
 
  virtual Model::GetTransitGatewayPrefixListReferencesOutcome GetTransitGatewayPrefixListReferences(
      const Model::GetTransitGatewayPrefixListReferencesRequest& request) const;
 
  template <typename GetTransitGatewayPrefixListReferencesRequestT = Model::GetTransitGatewayPrefixListReferencesRequest>
  Model::GetTransitGatewayPrefixListReferencesOutcomeCallable GetTransitGatewayPrefixListReferencesCallable(
      const GetTransitGatewayPrefixListReferencesRequestT& request) const {
    return SubmitCallable(&EC2Client::GetTransitGatewayPrefixListReferences, request);
  }
 
  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);
  }
 
  virtual Model::GetTransitGatewayRouteTableAssociationsOutcome GetTransitGatewayRouteTableAssociations(
      const Model::GetTransitGatewayRouteTableAssociationsRequest& request) const;
 
  template <typename GetTransitGatewayRouteTableAssociationsRequestT = Model::GetTransitGatewayRouteTableAssociationsRequest>
  Model::GetTransitGatewayRouteTableAssociationsOutcomeCallable GetTransitGatewayRouteTableAssociationsCallable(
      const GetTransitGatewayRouteTableAssociationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetTransitGatewayRouteTableAssociations, request);
  }
 
  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);
  }
 
  virtual Model::GetTransitGatewayRouteTablePropagationsOutcome GetTransitGatewayRouteTablePropagations(
      const Model::GetTransitGatewayRouteTablePropagationsRequest& request) const;
 
  template <typename GetTransitGatewayRouteTablePropagationsRequestT = Model::GetTransitGatewayRouteTablePropagationsRequest>
  Model::GetTransitGatewayRouteTablePropagationsOutcomeCallable GetTransitGatewayRouteTablePropagationsCallable(
      const GetTransitGatewayRouteTablePropagationsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetTransitGatewayRouteTablePropagations, request);
  }
 
  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);
  }
 
  virtual Model::GetVerifiedAccessEndpointPolicyOutcome GetVerifiedAccessEndpointPolicy(
      const Model::GetVerifiedAccessEndpointPolicyRequest& request) const;
 
  template <typename GetVerifiedAccessEndpointPolicyRequestT = Model::GetVerifiedAccessEndpointPolicyRequest>
  Model::GetVerifiedAccessEndpointPolicyOutcomeCallable GetVerifiedAccessEndpointPolicyCallable(
      const GetVerifiedAccessEndpointPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::GetVerifiedAccessEndpointPolicy, request);
  }
 
  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);
  }
 
  virtual Model::GetVerifiedAccessEndpointTargetsOutcome GetVerifiedAccessEndpointTargets(
      const Model::GetVerifiedAccessEndpointTargetsRequest& request) const;
 
  template <typename GetVerifiedAccessEndpointTargetsRequestT = Model::GetVerifiedAccessEndpointTargetsRequest>
  Model::GetVerifiedAccessEndpointTargetsOutcomeCallable GetVerifiedAccessEndpointTargetsCallable(
      const GetVerifiedAccessEndpointTargetsRequestT& request) const {
    return SubmitCallable(&EC2Client::GetVerifiedAccessEndpointTargets, request);
  }
 
  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);
  }
 
  virtual Model::GetVerifiedAccessGroupPolicyOutcome GetVerifiedAccessGroupPolicy(
      const Model::GetVerifiedAccessGroupPolicyRequest& request) const;
 
  template <typename GetVerifiedAccessGroupPolicyRequestT = Model::GetVerifiedAccessGroupPolicyRequest>
  Model::GetVerifiedAccessGroupPolicyOutcomeCallable GetVerifiedAccessGroupPolicyCallable(
      const GetVerifiedAccessGroupPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::GetVerifiedAccessGroupPolicy, request);
  }
 
  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);
  }
 
  virtual Model::GetVpcResourcesBlockingEncryptionEnforcementOutcome GetVpcResourcesBlockingEncryptionEnforcement(
      const Model::GetVpcResourcesBlockingEncryptionEnforcementRequest& request) const;
 
  template <typename GetVpcResourcesBlockingEncryptionEnforcementRequestT = Model::GetVpcResourcesBlockingEncryptionEnforcementRequest>
  Model::GetVpcResourcesBlockingEncryptionEnforcementOutcomeCallable GetVpcResourcesBlockingEncryptionEnforcementCallable(
      const GetVpcResourcesBlockingEncryptionEnforcementRequestT& request) const {
    return SubmitCallable(&EC2Client::GetVpcResourcesBlockingEncryptionEnforcement, request);
  }
 
  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);
  }
 
  virtual Model::GetVpnConnectionDeviceSampleConfigurationOutcome GetVpnConnectionDeviceSampleConfiguration(
      const Model::GetVpnConnectionDeviceSampleConfigurationRequest& request) const;
 
  template <typename GetVpnConnectionDeviceSampleConfigurationRequestT = Model::GetVpnConnectionDeviceSampleConfigurationRequest>
  Model::GetVpnConnectionDeviceSampleConfigurationOutcomeCallable GetVpnConnectionDeviceSampleConfigurationCallable(
      const GetVpnConnectionDeviceSampleConfigurationRequestT& request) const {
    return SubmitCallable(&EC2Client::GetVpnConnectionDeviceSampleConfiguration, request);
  }
 
  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);
  }
 
  virtual Model::GetVpnConnectionDeviceTypesOutcome GetVpnConnectionDeviceTypes(
      const Model::GetVpnConnectionDeviceTypesRequest& request = {}) const;
 
  template <typename GetVpnConnectionDeviceTypesRequestT = Model::GetVpnConnectionDeviceTypesRequest>
  Model::GetVpnConnectionDeviceTypesOutcomeCallable GetVpnConnectionDeviceTypesCallable(
      const GetVpnConnectionDeviceTypesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::GetVpnConnectionDeviceTypes, request);
  }
 
  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);
  }
 
  virtual Model::GetVpnTunnelReplacementStatusOutcome GetVpnTunnelReplacementStatus(
      const Model::GetVpnTunnelReplacementStatusRequest& request) const;
 
  template <typename GetVpnTunnelReplacementStatusRequestT = Model::GetVpnTunnelReplacementStatusRequest>
  Model::GetVpnTunnelReplacementStatusOutcomeCallable GetVpnTunnelReplacementStatusCallable(
      const GetVpnTunnelReplacementStatusRequestT& request) const {
    return SubmitCallable(&EC2Client::GetVpnTunnelReplacementStatus, request);
  }
 
  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);
  }
 
  virtual Model::ImportClientVpnClientCertificateRevocationListOutcome ImportClientVpnClientCertificateRevocationList(
      const Model::ImportClientVpnClientCertificateRevocationListRequest& request) const;
 
  template <typename ImportClientVpnClientCertificateRevocationListRequestT = Model::ImportClientVpnClientCertificateRevocationListRequest>
  Model::ImportClientVpnClientCertificateRevocationListOutcomeCallable ImportClientVpnClientCertificateRevocationListCallable(
      const ImportClientVpnClientCertificateRevocationListRequestT& request) const {
    return SubmitCallable(&EC2Client::ImportClientVpnClientCertificateRevocationList, request);
  }
 
  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);
  }
 
  virtual Model::ImportImageOutcome ImportImage(const Model::ImportImageRequest& request = {}) const;
 
  template <typename ImportImageRequestT = Model::ImportImageRequest>
  Model::ImportImageOutcomeCallable ImportImageCallable(const ImportImageRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ImportImage, request);
  }
 
  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);
  }
 
  virtual Model::ImportInstanceOutcome ImportInstance(const Model::ImportInstanceRequest& request) const;
 
  template <typename ImportInstanceRequestT = Model::ImportInstanceRequest>
  Model::ImportInstanceOutcomeCallable ImportInstanceCallable(const ImportInstanceRequestT& request) const {
    return SubmitCallable(&EC2Client::ImportInstance, request);
  }
 
  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);
  }
 
  virtual Model::ImportKeyPairOutcome ImportKeyPair(const Model::ImportKeyPairRequest& request) const;
 
  template <typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
  Model::ImportKeyPairOutcomeCallable ImportKeyPairCallable(const ImportKeyPairRequestT& request) const {
    return SubmitCallable(&EC2Client::ImportKeyPair, request);
  }
 
  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);
  }
 
  virtual Model::ImportSnapshotOutcome ImportSnapshot(const Model::ImportSnapshotRequest& request = {}) const;
 
  template <typename ImportSnapshotRequestT = Model::ImportSnapshotRequest>
  Model::ImportSnapshotOutcomeCallable ImportSnapshotCallable(const ImportSnapshotRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ImportSnapshot, request);
  }
 
  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);
  }
 
  virtual Model::ImportVolumeOutcome ImportVolume(const Model::ImportVolumeRequest& request) const;
 
  template <typename ImportVolumeRequestT = Model::ImportVolumeRequest>
  Model::ImportVolumeOutcomeCallable ImportVolumeCallable(const ImportVolumeRequestT& request) const {
    return SubmitCallable(&EC2Client::ImportVolume, request);
  }
 
  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);
  }
 
  virtual Model::ListImagesInRecycleBinOutcome ListImagesInRecycleBin(const Model::ListImagesInRecycleBinRequest& request = {}) const;
 
  template <typename ListImagesInRecycleBinRequestT = Model::ListImagesInRecycleBinRequest>
  Model::ListImagesInRecycleBinOutcomeCallable ListImagesInRecycleBinCallable(const ListImagesInRecycleBinRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ListImagesInRecycleBin, request);
  }
 
  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);
  }
 
  virtual Model::ListSnapshotsInRecycleBinOutcome ListSnapshotsInRecycleBin(
      const Model::ListSnapshotsInRecycleBinRequest& request = {}) const;
 
  template <typename ListSnapshotsInRecycleBinRequestT = Model::ListSnapshotsInRecycleBinRequest>
  Model::ListSnapshotsInRecycleBinOutcomeCallable ListSnapshotsInRecycleBinCallable(
      const ListSnapshotsInRecycleBinRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ListSnapshotsInRecycleBin, request);
  }
 
  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);
  }
 
  virtual Model::ListVolumesInRecycleBinOutcome ListVolumesInRecycleBin(const Model::ListVolumesInRecycleBinRequest& request = {}) const;
 
  template <typename ListVolumesInRecycleBinRequestT = Model::ListVolumesInRecycleBinRequest>
  Model::ListVolumesInRecycleBinOutcomeCallable ListVolumesInRecycleBinCallable(const ListVolumesInRecycleBinRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ListVolumesInRecycleBin, request);
  }
 
  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);
  }
 
  virtual Model::LockSnapshotOutcome LockSnapshot(const Model::LockSnapshotRequest& request) const;
 
  template <typename LockSnapshotRequestT = Model::LockSnapshotRequest>
  Model::LockSnapshotOutcomeCallable LockSnapshotCallable(const LockSnapshotRequestT& request) const {
    return SubmitCallable(&EC2Client::LockSnapshot, request);
  }
 
  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);
  }
 
  virtual Model::ModifyAccountVpcEncryptionControlOutcome ModifyAccountVpcEncryptionControl(
      const Model::ModifyAccountVpcEncryptionControlRequest& request = {}) const;
 
  template <typename ModifyAccountVpcEncryptionControlRequestT = Model::ModifyAccountVpcEncryptionControlRequest>
  Model::ModifyAccountVpcEncryptionControlOutcomeCallable ModifyAccountVpcEncryptionControlCallable(
      const ModifyAccountVpcEncryptionControlRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ModifyAccountVpcEncryptionControl, request);
  }
 
  template <typename ModifyAccountVpcEncryptionControlRequestT = Model::ModifyAccountVpcEncryptionControlRequest>
  void ModifyAccountVpcEncryptionControlAsync(const ModifyAccountVpcEncryptionControlResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const ModifyAccountVpcEncryptionControlRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::ModifyAccountVpcEncryptionControl, request, handler, context);
  }
 
  virtual Model::ModifyAddressAttributeOutcome ModifyAddressAttribute(const Model::ModifyAddressAttributeRequest& request) const;
 
  template <typename ModifyAddressAttributeRequestT = Model::ModifyAddressAttributeRequest>
  Model::ModifyAddressAttributeOutcomeCallable ModifyAddressAttributeCallable(const ModifyAddressAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyAddressAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ModifyAvailabilityZoneGroupOutcome ModifyAvailabilityZoneGroup(
      const Model::ModifyAvailabilityZoneGroupRequest& request) const;
 
  template <typename ModifyAvailabilityZoneGroupRequestT = Model::ModifyAvailabilityZoneGroupRequest>
  Model::ModifyAvailabilityZoneGroupOutcomeCallable ModifyAvailabilityZoneGroupCallable(
      const ModifyAvailabilityZoneGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyAvailabilityZoneGroup, request);
  }
 
  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);
  }
 
  virtual Model::ModifyCapacityReservationOutcome ModifyCapacityReservation(const Model::ModifyCapacityReservationRequest& request) const;
 
  template <typename ModifyCapacityReservationRequestT = Model::ModifyCapacityReservationRequest>
  Model::ModifyCapacityReservationOutcomeCallable ModifyCapacityReservationCallable(
      const ModifyCapacityReservationRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyCapacityReservation, request);
  }
 
  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);
  }
 
  virtual Model::ModifyCapacityReservationFleetOutcome ModifyCapacityReservationFleet(
      const Model::ModifyCapacityReservationFleetRequest& request) const;
 
  template <typename ModifyCapacityReservationFleetRequestT = Model::ModifyCapacityReservationFleetRequest>
  Model::ModifyCapacityReservationFleetOutcomeCallable ModifyCapacityReservationFleetCallable(
      const ModifyCapacityReservationFleetRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyCapacityReservationFleet, request);
  }
 
  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);
  }
 
  virtual Model::ModifyClientVpnEndpointOutcome ModifyClientVpnEndpoint(const Model::ModifyClientVpnEndpointRequest& request) const;
 
  template <typename ModifyClientVpnEndpointRequestT = Model::ModifyClientVpnEndpointRequest>
  Model::ModifyClientVpnEndpointOutcomeCallable ModifyClientVpnEndpointCallable(const ModifyClientVpnEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyClientVpnEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::ModifyDefaultCreditSpecificationOutcome ModifyDefaultCreditSpecification(
      const Model::ModifyDefaultCreditSpecificationRequest& request) const;
 
  template <typename ModifyDefaultCreditSpecificationRequestT = Model::ModifyDefaultCreditSpecificationRequest>
  Model::ModifyDefaultCreditSpecificationOutcomeCallable ModifyDefaultCreditSpecificationCallable(
      const ModifyDefaultCreditSpecificationRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyDefaultCreditSpecification, request);
  }
 
  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);
  }
 
  virtual Model::ModifyEbsDefaultKmsKeyIdOutcome ModifyEbsDefaultKmsKeyId(const Model::ModifyEbsDefaultKmsKeyIdRequest& request) const;
 
  template <typename ModifyEbsDefaultKmsKeyIdRequestT = Model::ModifyEbsDefaultKmsKeyIdRequest>
  Model::ModifyEbsDefaultKmsKeyIdOutcomeCallable ModifyEbsDefaultKmsKeyIdCallable(const ModifyEbsDefaultKmsKeyIdRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyEbsDefaultKmsKeyId, request);
  }
 
  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);
  }
 
  virtual Model::ModifyFleetOutcome ModifyFleet(const Model::ModifyFleetRequest& request) const;
 
  template <typename ModifyFleetRequestT = Model::ModifyFleetRequest>
  Model::ModifyFleetOutcomeCallable ModifyFleetCallable(const ModifyFleetRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyFleet, request);
  }
 
  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);
  }
 
  virtual Model::ModifyFpgaImageAttributeOutcome ModifyFpgaImageAttribute(const Model::ModifyFpgaImageAttributeRequest& request) const;
 
  template <typename ModifyFpgaImageAttributeRequestT = Model::ModifyFpgaImageAttributeRequest>
  Model::ModifyFpgaImageAttributeOutcomeCallable ModifyFpgaImageAttributeCallable(const ModifyFpgaImageAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyFpgaImageAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ModifyHostsOutcome ModifyHosts(const Model::ModifyHostsRequest& request) const;
 
  template <typename ModifyHostsRequestT = Model::ModifyHostsRequest>
  Model::ModifyHostsOutcomeCallable ModifyHostsCallable(const ModifyHostsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyHosts, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIdFormatOutcome ModifyIdFormat(const Model::ModifyIdFormatRequest& request) const;
 
  template <typename ModifyIdFormatRequestT = Model::ModifyIdFormatRequest>
  Model::ModifyIdFormatOutcomeCallable ModifyIdFormatCallable(const ModifyIdFormatRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIdFormat, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIdentityIdFormatOutcome ModifyIdentityIdFormat(const Model::ModifyIdentityIdFormatRequest& request) const;
 
  template <typename ModifyIdentityIdFormatRequestT = Model::ModifyIdentityIdFormatRequest>
  Model::ModifyIdentityIdFormatOutcomeCallable ModifyIdentityIdFormatCallable(const ModifyIdentityIdFormatRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIdentityIdFormat, request);
  }
 
  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);
  }
 
  virtual Model::ModifyImageAttributeOutcome ModifyImageAttribute(const Model::ModifyImageAttributeRequest& request) const;
 
  template <typename ModifyImageAttributeRequestT = Model::ModifyImageAttributeRequest>
  Model::ModifyImageAttributeOutcomeCallable ModifyImageAttributeCallable(const ModifyImageAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyImageAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceAttributeOutcome ModifyInstanceAttribute(const Model::ModifyInstanceAttributeRequest& request) const;
 
  template <typename ModifyInstanceAttributeRequestT = Model::ModifyInstanceAttributeRequest>
  Model::ModifyInstanceAttributeOutcomeCallable ModifyInstanceAttributeCallable(const ModifyInstanceAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceCapacityReservationAttributesOutcome ModifyInstanceCapacityReservationAttributes(
      const Model::ModifyInstanceCapacityReservationAttributesRequest& request) const;
 
  template <typename ModifyInstanceCapacityReservationAttributesRequestT = Model::ModifyInstanceCapacityReservationAttributesRequest>
  Model::ModifyInstanceCapacityReservationAttributesOutcomeCallable ModifyInstanceCapacityReservationAttributesCallable(
      const ModifyInstanceCapacityReservationAttributesRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceCapacityReservationAttributes, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceConnectEndpointOutcome ModifyInstanceConnectEndpoint(
      const Model::ModifyInstanceConnectEndpointRequest& request) const;
 
  template <typename ModifyInstanceConnectEndpointRequestT = Model::ModifyInstanceConnectEndpointRequest>
  Model::ModifyInstanceConnectEndpointOutcomeCallable ModifyInstanceConnectEndpointCallable(
      const ModifyInstanceConnectEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceConnectEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceCpuOptionsOutcome ModifyInstanceCpuOptions(const Model::ModifyInstanceCpuOptionsRequest& request) const;
 
  template <typename ModifyInstanceCpuOptionsRequestT = Model::ModifyInstanceCpuOptionsRequest>
  Model::ModifyInstanceCpuOptionsOutcomeCallable ModifyInstanceCpuOptionsCallable(const ModifyInstanceCpuOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceCpuOptions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceCreditSpecificationOutcome ModifyInstanceCreditSpecification(
      const Model::ModifyInstanceCreditSpecificationRequest& request) const;
 
  template <typename ModifyInstanceCreditSpecificationRequestT = Model::ModifyInstanceCreditSpecificationRequest>
  Model::ModifyInstanceCreditSpecificationOutcomeCallable ModifyInstanceCreditSpecificationCallable(
      const ModifyInstanceCreditSpecificationRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceCreditSpecification, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceEventStartTimeOutcome ModifyInstanceEventStartTime(
      const Model::ModifyInstanceEventStartTimeRequest& request) const;
 
  template <typename ModifyInstanceEventStartTimeRequestT = Model::ModifyInstanceEventStartTimeRequest>
  Model::ModifyInstanceEventStartTimeOutcomeCallable ModifyInstanceEventStartTimeCallable(
      const ModifyInstanceEventStartTimeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceEventStartTime, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceEventWindowOutcome ModifyInstanceEventWindow(const Model::ModifyInstanceEventWindowRequest& request) const;
 
  template <typename ModifyInstanceEventWindowRequestT = Model::ModifyInstanceEventWindowRequest>
  Model::ModifyInstanceEventWindowOutcomeCallable ModifyInstanceEventWindowCallable(
      const ModifyInstanceEventWindowRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceEventWindow, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceMaintenanceOptionsOutcome ModifyInstanceMaintenanceOptions(
      const Model::ModifyInstanceMaintenanceOptionsRequest& request) const;
 
  template <typename ModifyInstanceMaintenanceOptionsRequestT = Model::ModifyInstanceMaintenanceOptionsRequest>
  Model::ModifyInstanceMaintenanceOptionsOutcomeCallable ModifyInstanceMaintenanceOptionsCallable(
      const ModifyInstanceMaintenanceOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceMaintenanceOptions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceMetadataDefaultsOutcome ModifyInstanceMetadataDefaults(
      const Model::ModifyInstanceMetadataDefaultsRequest& request = {}) const;
 
  template <typename ModifyInstanceMetadataDefaultsRequestT = Model::ModifyInstanceMetadataDefaultsRequest>
  Model::ModifyInstanceMetadataDefaultsOutcomeCallable ModifyInstanceMetadataDefaultsCallable(
      const ModifyInstanceMetadataDefaultsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ModifyInstanceMetadataDefaults, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceMetadataOptionsOutcome ModifyInstanceMetadataOptions(
      const Model::ModifyInstanceMetadataOptionsRequest& request) const;
 
  template <typename ModifyInstanceMetadataOptionsRequestT = Model::ModifyInstanceMetadataOptionsRequest>
  Model::ModifyInstanceMetadataOptionsOutcomeCallable ModifyInstanceMetadataOptionsCallable(
      const ModifyInstanceMetadataOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceMetadataOptions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstanceNetworkPerformanceOptionsOutcome ModifyInstanceNetworkPerformanceOptions(
      const Model::ModifyInstanceNetworkPerformanceOptionsRequest& request) const;
 
  template <typename ModifyInstanceNetworkPerformanceOptionsRequestT = Model::ModifyInstanceNetworkPerformanceOptionsRequest>
  Model::ModifyInstanceNetworkPerformanceOptionsOutcomeCallable ModifyInstanceNetworkPerformanceOptionsCallable(
      const ModifyInstanceNetworkPerformanceOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstanceNetworkPerformanceOptions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyInstancePlacementOutcome ModifyInstancePlacement(const Model::ModifyInstancePlacementRequest& request) const;
 
  template <typename ModifyInstancePlacementRequestT = Model::ModifyInstancePlacementRequest>
  Model::ModifyInstancePlacementOutcomeCallable ModifyInstancePlacementCallable(const ModifyInstancePlacementRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyInstancePlacement, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIpamOutcome ModifyIpam(const Model::ModifyIpamRequest& request) const;
 
  template <typename ModifyIpamRequestT = Model::ModifyIpamRequest>
  Model::ModifyIpamOutcomeCallable ModifyIpamCallable(const ModifyIpamRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpam, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIpamPolicyAllocationRulesOutcome ModifyIpamPolicyAllocationRules(
      const Model::ModifyIpamPolicyAllocationRulesRequest& request) const;
 
  template <typename ModifyIpamPolicyAllocationRulesRequestT = Model::ModifyIpamPolicyAllocationRulesRequest>
  Model::ModifyIpamPolicyAllocationRulesOutcomeCallable ModifyIpamPolicyAllocationRulesCallable(
      const ModifyIpamPolicyAllocationRulesRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamPolicyAllocationRules, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIpamPoolOutcome ModifyIpamPool(const Model::ModifyIpamPoolRequest& request) const;
 
  template <typename ModifyIpamPoolRequestT = Model::ModifyIpamPoolRequest>
  Model::ModifyIpamPoolOutcomeCallable ModifyIpamPoolCallable(const ModifyIpamPoolRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamPool, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIpamPoolAllocationOutcome ModifyIpamPoolAllocation(const Model::ModifyIpamPoolAllocationRequest& request) const;
 
  template <typename ModifyIpamPoolAllocationRequestT = Model::ModifyIpamPoolAllocationRequest>
  Model::ModifyIpamPoolAllocationOutcomeCallable ModifyIpamPoolAllocationCallable(const ModifyIpamPoolAllocationRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamPoolAllocation, request);
  }
 
  template <typename ModifyIpamPoolAllocationRequestT = Model::ModifyIpamPoolAllocationRequest>
  void ModifyIpamPoolAllocationAsync(const ModifyIpamPoolAllocationRequestT& request,
                                     const ModifyIpamPoolAllocationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyIpamPoolAllocation, request, handler, context);
  }
 
  virtual Model::ModifyIpamPrefixListResolverOutcome ModifyIpamPrefixListResolver(
      const Model::ModifyIpamPrefixListResolverRequest& request) const;
 
  template <typename ModifyIpamPrefixListResolverRequestT = Model::ModifyIpamPrefixListResolverRequest>
  Model::ModifyIpamPrefixListResolverOutcomeCallable ModifyIpamPrefixListResolverCallable(
      const ModifyIpamPrefixListResolverRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamPrefixListResolver, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIpamPrefixListResolverTargetOutcome ModifyIpamPrefixListResolverTarget(
      const Model::ModifyIpamPrefixListResolverTargetRequest& request) const;
 
  template <typename ModifyIpamPrefixListResolverTargetRequestT = Model::ModifyIpamPrefixListResolverTargetRequest>
  Model::ModifyIpamPrefixListResolverTargetOutcomeCallable ModifyIpamPrefixListResolverTargetCallable(
      const ModifyIpamPrefixListResolverTargetRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamPrefixListResolverTarget, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIpamResourceCidrOutcome ModifyIpamResourceCidr(const Model::ModifyIpamResourceCidrRequest& request) const;
 
  template <typename ModifyIpamResourceCidrRequestT = Model::ModifyIpamResourceCidrRequest>
  Model::ModifyIpamResourceCidrOutcomeCallable ModifyIpamResourceCidrCallable(const ModifyIpamResourceCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamResourceCidr, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIpamResourceDiscoveryOutcome ModifyIpamResourceDiscovery(
      const Model::ModifyIpamResourceDiscoveryRequest& request) const;
 
  template <typename ModifyIpamResourceDiscoveryRequestT = Model::ModifyIpamResourceDiscoveryRequest>
  Model::ModifyIpamResourceDiscoveryOutcomeCallable ModifyIpamResourceDiscoveryCallable(
      const ModifyIpamResourceDiscoveryRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamResourceDiscovery, request);
  }
 
  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);
  }
 
  virtual Model::ModifyIpamScopeOutcome ModifyIpamScope(const Model::ModifyIpamScopeRequest& request) const;
 
  template <typename ModifyIpamScopeRequestT = Model::ModifyIpamScopeRequest>
  Model::ModifyIpamScopeOutcomeCallable ModifyIpamScopeCallable(const ModifyIpamScopeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyIpamScope, request);
  }
 
  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);
  }
 
  virtual Model::ModifyLaunchTemplateOutcome ModifyLaunchTemplate(const Model::ModifyLaunchTemplateRequest& request = {}) const;
 
  template <typename ModifyLaunchTemplateRequestT = Model::ModifyLaunchTemplateRequest>
  Model::ModifyLaunchTemplateOutcomeCallable ModifyLaunchTemplateCallable(const ModifyLaunchTemplateRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ModifyLaunchTemplate, request);
  }
 
  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);
  }
 
  virtual Model::ModifyLocalGatewayRouteOutcome ModifyLocalGatewayRoute(const Model::ModifyLocalGatewayRouteRequest& request) const;
 
  template <typename ModifyLocalGatewayRouteRequestT = Model::ModifyLocalGatewayRouteRequest>
  Model::ModifyLocalGatewayRouteOutcomeCallable ModifyLocalGatewayRouteCallable(const ModifyLocalGatewayRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyLocalGatewayRoute, request);
  }
 
  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);
  }
 
  virtual Model::ModifyManagedPrefixListOutcome ModifyManagedPrefixList(const Model::ModifyManagedPrefixListRequest& request) const;
 
  template <typename ModifyManagedPrefixListRequestT = Model::ModifyManagedPrefixListRequest>
  Model::ModifyManagedPrefixListOutcomeCallable ModifyManagedPrefixListCallable(const ModifyManagedPrefixListRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyManagedPrefixList, request);
  }
 
  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);
  }
 
  virtual Model::ModifyManagedResourceVisibilityOutcome ModifyManagedResourceVisibility(
      const Model::ModifyManagedResourceVisibilityRequest& request) const;
 
  template <typename ModifyManagedResourceVisibilityRequestT = Model::ModifyManagedResourceVisibilityRequest>
  Model::ModifyManagedResourceVisibilityOutcomeCallable ModifyManagedResourceVisibilityCallable(
      const ModifyManagedResourceVisibilityRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyManagedResourceVisibility, request);
  }
 
  template <typename ModifyManagedResourceVisibilityRequestT = Model::ModifyManagedResourceVisibilityRequest>
  void ModifyManagedResourceVisibilityAsync(const ModifyManagedResourceVisibilityRequestT& request,
                                            const ModifyManagedResourceVisibilityResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyManagedResourceVisibility, request, handler, context);
  }
 
  virtual Model::ModifyNetworkInterfaceAttributeOutcome ModifyNetworkInterfaceAttribute(
      const Model::ModifyNetworkInterfaceAttributeRequest& request) const;
 
  template <typename ModifyNetworkInterfaceAttributeRequestT = Model::ModifyNetworkInterfaceAttributeRequest>
  Model::ModifyNetworkInterfaceAttributeOutcomeCallable ModifyNetworkInterfaceAttributeCallable(
      const ModifyNetworkInterfaceAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyNetworkInterfaceAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ModifyPrivateDnsNameOptionsOutcome ModifyPrivateDnsNameOptions(
      const Model::ModifyPrivateDnsNameOptionsRequest& request) const;
 
  template <typename ModifyPrivateDnsNameOptionsRequestT = Model::ModifyPrivateDnsNameOptionsRequest>
  Model::ModifyPrivateDnsNameOptionsOutcomeCallable ModifyPrivateDnsNameOptionsCallable(
      const ModifyPrivateDnsNameOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyPrivateDnsNameOptions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyPublicIpDnsNameOptionsOutcome ModifyPublicIpDnsNameOptions(
      const Model::ModifyPublicIpDnsNameOptionsRequest& request) const;
 
  template <typename ModifyPublicIpDnsNameOptionsRequestT = Model::ModifyPublicIpDnsNameOptionsRequest>
  Model::ModifyPublicIpDnsNameOptionsOutcomeCallable ModifyPublicIpDnsNameOptionsCallable(
      const ModifyPublicIpDnsNameOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyPublicIpDnsNameOptions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyReservedInstancesOutcome ModifyReservedInstances(const Model::ModifyReservedInstancesRequest& request) const;
 
  template <typename ModifyReservedInstancesRequestT = Model::ModifyReservedInstancesRequest>
  Model::ModifyReservedInstancesOutcomeCallable ModifyReservedInstancesCallable(const ModifyReservedInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyReservedInstances, request);
  }
 
  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);
  }
 
  virtual Model::ModifyRouteServerOutcome ModifyRouteServer(const Model::ModifyRouteServerRequest& request) const;
 
  template <typename ModifyRouteServerRequestT = Model::ModifyRouteServerRequest>
  Model::ModifyRouteServerOutcomeCallable ModifyRouteServerCallable(const ModifyRouteServerRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyRouteServer, request);
  }
 
  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);
  }
 
  virtual Model::ModifySecurityGroupRulesOutcome ModifySecurityGroupRules(const Model::ModifySecurityGroupRulesRequest& request) const;
 
  template <typename ModifySecurityGroupRulesRequestT = Model::ModifySecurityGroupRulesRequest>
  Model::ModifySecurityGroupRulesOutcomeCallable ModifySecurityGroupRulesCallable(const ModifySecurityGroupRulesRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifySecurityGroupRules, request);
  }
 
  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);
  }
 
  virtual Model::ModifySnapshotAttributeOutcome ModifySnapshotAttribute(const Model::ModifySnapshotAttributeRequest& request) const;
 
  template <typename ModifySnapshotAttributeRequestT = Model::ModifySnapshotAttributeRequest>
  Model::ModifySnapshotAttributeOutcomeCallable ModifySnapshotAttributeCallable(const ModifySnapshotAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifySnapshotAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ModifySnapshotTierOutcome ModifySnapshotTier(const Model::ModifySnapshotTierRequest& request) const;
 
  template <typename ModifySnapshotTierRequestT = Model::ModifySnapshotTierRequest>
  Model::ModifySnapshotTierOutcomeCallable ModifySnapshotTierCallable(const ModifySnapshotTierRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifySnapshotTier, request);
  }
 
  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);
  }
 
  virtual Model::ModifySpotFleetRequestOutcome ModifySpotFleetRequest(const Model::ModifySpotFleetRequestRequest& request) const;
 
  template <typename ModifySpotFleetRequestRequestT = Model::ModifySpotFleetRequestRequest>
  Model::ModifySpotFleetRequestOutcomeCallable ModifySpotFleetRequestCallable(const ModifySpotFleetRequestRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifySpotFleetRequest, request);
  }
 
  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);
  }
 
  virtual Model::ModifySubnetAttributeOutcome ModifySubnetAttribute(const Model::ModifySubnetAttributeRequest& request) const;
 
  template <typename ModifySubnetAttributeRequestT = Model::ModifySubnetAttributeRequest>
  Model::ModifySubnetAttributeOutcomeCallable ModifySubnetAttributeCallable(const ModifySubnetAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifySubnetAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ModifyTrafficMirrorFilterNetworkServicesOutcome ModifyTrafficMirrorFilterNetworkServices(
      const Model::ModifyTrafficMirrorFilterNetworkServicesRequest& request) const;
 
  template <typename ModifyTrafficMirrorFilterNetworkServicesRequestT = Model::ModifyTrafficMirrorFilterNetworkServicesRequest>
  Model::ModifyTrafficMirrorFilterNetworkServicesOutcomeCallable ModifyTrafficMirrorFilterNetworkServicesCallable(
      const ModifyTrafficMirrorFilterNetworkServicesRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyTrafficMirrorFilterNetworkServices, request);
  }
 
  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);
  }
 
  virtual Model::ModifyTrafficMirrorFilterRuleOutcome ModifyTrafficMirrorFilterRule(
      const Model::ModifyTrafficMirrorFilterRuleRequest& request) const;
 
  template <typename ModifyTrafficMirrorFilterRuleRequestT = Model::ModifyTrafficMirrorFilterRuleRequest>
  Model::ModifyTrafficMirrorFilterRuleOutcomeCallable ModifyTrafficMirrorFilterRuleCallable(
      const ModifyTrafficMirrorFilterRuleRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyTrafficMirrorFilterRule, request);
  }
 
  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);
  }
 
  virtual Model::ModifyTrafficMirrorSessionOutcome ModifyTrafficMirrorSession(
      const Model::ModifyTrafficMirrorSessionRequest& request) const;
 
  template <typename ModifyTrafficMirrorSessionRequestT = Model::ModifyTrafficMirrorSessionRequest>
  Model::ModifyTrafficMirrorSessionOutcomeCallable ModifyTrafficMirrorSessionCallable(
      const ModifyTrafficMirrorSessionRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyTrafficMirrorSession, request);
  }
 
  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);
  }
 
  virtual Model::ModifyTransitGatewayOutcome ModifyTransitGateway(const Model::ModifyTransitGatewayRequest& request) const;
 
  template <typename ModifyTransitGatewayRequestT = Model::ModifyTransitGatewayRequest>
  Model::ModifyTransitGatewayOutcomeCallable ModifyTransitGatewayCallable(const ModifyTransitGatewayRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyTransitGateway, request);
  }
 
  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);
  }
 
  virtual Model::ModifyTransitGatewayMeteringPolicyOutcome ModifyTransitGatewayMeteringPolicy(
      const Model::ModifyTransitGatewayMeteringPolicyRequest& request) const;
 
  template <typename ModifyTransitGatewayMeteringPolicyRequestT = Model::ModifyTransitGatewayMeteringPolicyRequest>
  Model::ModifyTransitGatewayMeteringPolicyOutcomeCallable ModifyTransitGatewayMeteringPolicyCallable(
      const ModifyTransitGatewayMeteringPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyTransitGatewayMeteringPolicy, request);
  }
 
  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);
  }
 
  virtual Model::ModifyTransitGatewayPrefixListReferenceOutcome ModifyTransitGatewayPrefixListReference(
      const Model::ModifyTransitGatewayPrefixListReferenceRequest& request) const;
 
  template <typename ModifyTransitGatewayPrefixListReferenceRequestT = Model::ModifyTransitGatewayPrefixListReferenceRequest>
  Model::ModifyTransitGatewayPrefixListReferenceOutcomeCallable ModifyTransitGatewayPrefixListReferenceCallable(
      const ModifyTransitGatewayPrefixListReferenceRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyTransitGatewayPrefixListReference, request);
  }
 
  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);
  }
 
  virtual Model::ModifyTransitGatewayVpcAttachmentOutcome ModifyTransitGatewayVpcAttachment(
      const Model::ModifyTransitGatewayVpcAttachmentRequest& request) const;
 
  template <typename ModifyTransitGatewayVpcAttachmentRequestT = Model::ModifyTransitGatewayVpcAttachmentRequest>
  Model::ModifyTransitGatewayVpcAttachmentOutcomeCallable ModifyTransitGatewayVpcAttachmentCallable(
      const ModifyTransitGatewayVpcAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyTransitGatewayVpcAttachment, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVerifiedAccessEndpointOutcome ModifyVerifiedAccessEndpoint(
      const Model::ModifyVerifiedAccessEndpointRequest& request) const;
 
  template <typename ModifyVerifiedAccessEndpointRequestT = Model::ModifyVerifiedAccessEndpointRequest>
  Model::ModifyVerifiedAccessEndpointOutcomeCallable ModifyVerifiedAccessEndpointCallable(
      const ModifyVerifiedAccessEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVerifiedAccessEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVerifiedAccessEndpointPolicyOutcome ModifyVerifiedAccessEndpointPolicy(
      const Model::ModifyVerifiedAccessEndpointPolicyRequest& request) const;
 
  template <typename ModifyVerifiedAccessEndpointPolicyRequestT = Model::ModifyVerifiedAccessEndpointPolicyRequest>
  Model::ModifyVerifiedAccessEndpointPolicyOutcomeCallable ModifyVerifiedAccessEndpointPolicyCallable(
      const ModifyVerifiedAccessEndpointPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVerifiedAccessEndpointPolicy, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVerifiedAccessGroupOutcome ModifyVerifiedAccessGroup(const Model::ModifyVerifiedAccessGroupRequest& request) const;
 
  template <typename ModifyVerifiedAccessGroupRequestT = Model::ModifyVerifiedAccessGroupRequest>
  Model::ModifyVerifiedAccessGroupOutcomeCallable ModifyVerifiedAccessGroupCallable(
      const ModifyVerifiedAccessGroupRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVerifiedAccessGroup, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVerifiedAccessGroupPolicyOutcome ModifyVerifiedAccessGroupPolicy(
      const Model::ModifyVerifiedAccessGroupPolicyRequest& request) const;
 
  template <typename ModifyVerifiedAccessGroupPolicyRequestT = Model::ModifyVerifiedAccessGroupPolicyRequest>
  Model::ModifyVerifiedAccessGroupPolicyOutcomeCallable ModifyVerifiedAccessGroupPolicyCallable(
      const ModifyVerifiedAccessGroupPolicyRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVerifiedAccessGroupPolicy, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVerifiedAccessInstanceOutcome ModifyVerifiedAccessInstance(
      const Model::ModifyVerifiedAccessInstanceRequest& request) const;
 
  template <typename ModifyVerifiedAccessInstanceRequestT = Model::ModifyVerifiedAccessInstanceRequest>
  Model::ModifyVerifiedAccessInstanceOutcomeCallable ModifyVerifiedAccessInstanceCallable(
      const ModifyVerifiedAccessInstanceRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVerifiedAccessInstance, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVerifiedAccessInstanceLoggingConfigurationOutcome ModifyVerifiedAccessInstanceLoggingConfiguration(
      const Model::ModifyVerifiedAccessInstanceLoggingConfigurationRequest& request) const;
 
  template <
      typename ModifyVerifiedAccessInstanceLoggingConfigurationRequestT = Model::ModifyVerifiedAccessInstanceLoggingConfigurationRequest>
  Model::ModifyVerifiedAccessInstanceLoggingConfigurationOutcomeCallable ModifyVerifiedAccessInstanceLoggingConfigurationCallable(
      const ModifyVerifiedAccessInstanceLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVerifiedAccessInstanceLoggingConfiguration, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVerifiedAccessTrustProviderOutcome ModifyVerifiedAccessTrustProvider(
      const Model::ModifyVerifiedAccessTrustProviderRequest& request) const;
 
  template <typename ModifyVerifiedAccessTrustProviderRequestT = Model::ModifyVerifiedAccessTrustProviderRequest>
  Model::ModifyVerifiedAccessTrustProviderOutcomeCallable ModifyVerifiedAccessTrustProviderCallable(
      const ModifyVerifiedAccessTrustProviderRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVerifiedAccessTrustProvider, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVolumeOutcome ModifyVolume(const Model::ModifyVolumeRequest& request) const;
 
  template <typename ModifyVolumeRequestT = Model::ModifyVolumeRequest>
  Model::ModifyVolumeOutcomeCallable ModifyVolumeCallable(const ModifyVolumeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVolume, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVolumeAttributeOutcome ModifyVolumeAttribute(const Model::ModifyVolumeAttributeRequest& request) const;
 
  template <typename ModifyVolumeAttributeRequestT = Model::ModifyVolumeAttributeRequest>
  Model::ModifyVolumeAttributeOutcomeCallable ModifyVolumeAttributeCallable(const ModifyVolumeAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVolumeAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcAttributeOutcome ModifyVpcAttribute(const Model::ModifyVpcAttributeRequest& request) const;
 
  template <typename ModifyVpcAttributeRequestT = Model::ModifyVpcAttributeRequest>
  Model::ModifyVpcAttributeOutcomeCallable ModifyVpcAttributeCallable(const ModifyVpcAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcBlockPublicAccessExclusionOutcome ModifyVpcBlockPublicAccessExclusion(
      const Model::ModifyVpcBlockPublicAccessExclusionRequest& request) const;
 
  template <typename ModifyVpcBlockPublicAccessExclusionRequestT = Model::ModifyVpcBlockPublicAccessExclusionRequest>
  Model::ModifyVpcBlockPublicAccessExclusionOutcomeCallable ModifyVpcBlockPublicAccessExclusionCallable(
      const ModifyVpcBlockPublicAccessExclusionRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcBlockPublicAccessExclusion, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcBlockPublicAccessOptionsOutcome ModifyVpcBlockPublicAccessOptions(
      const Model::ModifyVpcBlockPublicAccessOptionsRequest& request) const;
 
  template <typename ModifyVpcBlockPublicAccessOptionsRequestT = Model::ModifyVpcBlockPublicAccessOptionsRequest>
  Model::ModifyVpcBlockPublicAccessOptionsOutcomeCallable ModifyVpcBlockPublicAccessOptionsCallable(
      const ModifyVpcBlockPublicAccessOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcBlockPublicAccessOptions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcEncryptionControlOutcome ModifyVpcEncryptionControl(
      const Model::ModifyVpcEncryptionControlRequest& request) const;
 
  template <typename ModifyVpcEncryptionControlRequestT = Model::ModifyVpcEncryptionControlRequest>
  Model::ModifyVpcEncryptionControlOutcomeCallable ModifyVpcEncryptionControlCallable(
      const ModifyVpcEncryptionControlRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcEncryptionControl, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcEndpointOutcome ModifyVpcEndpoint(const Model::ModifyVpcEndpointRequest& request) const;
 
  template <typename ModifyVpcEndpointRequestT = Model::ModifyVpcEndpointRequest>
  Model::ModifyVpcEndpointOutcomeCallable ModifyVpcEndpointCallable(const ModifyVpcEndpointRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcEndpoint, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcEndpointConnectionNotificationOutcome ModifyVpcEndpointConnectionNotification(
      const Model::ModifyVpcEndpointConnectionNotificationRequest& request) const;
 
  template <typename ModifyVpcEndpointConnectionNotificationRequestT = Model::ModifyVpcEndpointConnectionNotificationRequest>
  Model::ModifyVpcEndpointConnectionNotificationOutcomeCallable ModifyVpcEndpointConnectionNotificationCallable(
      const ModifyVpcEndpointConnectionNotificationRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcEndpointConnectionNotification, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcEndpointPayerResponsibilityOutcome ModifyVpcEndpointPayerResponsibility(
      const Model::ModifyVpcEndpointPayerResponsibilityRequest& request) const;
 
  template <typename ModifyVpcEndpointPayerResponsibilityRequestT = Model::ModifyVpcEndpointPayerResponsibilityRequest>
  Model::ModifyVpcEndpointPayerResponsibilityOutcomeCallable ModifyVpcEndpointPayerResponsibilityCallable(
      const ModifyVpcEndpointPayerResponsibilityRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcEndpointPayerResponsibility, request);
  }
 
  template <typename ModifyVpcEndpointPayerResponsibilityRequestT = Model::ModifyVpcEndpointPayerResponsibilityRequest>
  void ModifyVpcEndpointPayerResponsibilityAsync(const ModifyVpcEndpointPayerResponsibilityRequestT& request,
                                                 const ModifyVpcEndpointPayerResponsibilityResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::ModifyVpcEndpointPayerResponsibility, request, handler, context);
  }
 
  virtual Model::ModifyVpcEndpointServiceConfigurationOutcome ModifyVpcEndpointServiceConfiguration(
      const Model::ModifyVpcEndpointServiceConfigurationRequest& request) const;
 
  template <typename ModifyVpcEndpointServiceConfigurationRequestT = Model::ModifyVpcEndpointServiceConfigurationRequest>
  Model::ModifyVpcEndpointServiceConfigurationOutcomeCallable ModifyVpcEndpointServiceConfigurationCallable(
      const ModifyVpcEndpointServiceConfigurationRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcEndpointServiceConfiguration, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcEndpointServicePayerResponsibilityOutcome ModifyVpcEndpointServicePayerResponsibility(
      const Model::ModifyVpcEndpointServicePayerResponsibilityRequest& request) const;
 
  template <typename ModifyVpcEndpointServicePayerResponsibilityRequestT = Model::ModifyVpcEndpointServicePayerResponsibilityRequest>
  Model::ModifyVpcEndpointServicePayerResponsibilityOutcomeCallable ModifyVpcEndpointServicePayerResponsibilityCallable(
      const ModifyVpcEndpointServicePayerResponsibilityRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcEndpointServicePayerResponsibility, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcEndpointServicePermissionsOutcome ModifyVpcEndpointServicePermissions(
      const Model::ModifyVpcEndpointServicePermissionsRequest& request) const;
 
  template <typename ModifyVpcEndpointServicePermissionsRequestT = Model::ModifyVpcEndpointServicePermissionsRequest>
  Model::ModifyVpcEndpointServicePermissionsOutcomeCallable ModifyVpcEndpointServicePermissionsCallable(
      const ModifyVpcEndpointServicePermissionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcEndpointServicePermissions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcPeeringConnectionOptionsOutcome ModifyVpcPeeringConnectionOptions(
      const Model::ModifyVpcPeeringConnectionOptionsRequest& request) const;
 
  template <typename ModifyVpcPeeringConnectionOptionsRequestT = Model::ModifyVpcPeeringConnectionOptionsRequest>
  Model::ModifyVpcPeeringConnectionOptionsOutcomeCallable ModifyVpcPeeringConnectionOptionsCallable(
      const ModifyVpcPeeringConnectionOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcPeeringConnectionOptions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpcTenancyOutcome ModifyVpcTenancy(const Model::ModifyVpcTenancyRequest& request) const;
 
  template <typename ModifyVpcTenancyRequestT = Model::ModifyVpcTenancyRequest>
  Model::ModifyVpcTenancyOutcomeCallable ModifyVpcTenancyCallable(const ModifyVpcTenancyRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpcTenancy, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpnConnectionOutcome ModifyVpnConnection(const Model::ModifyVpnConnectionRequest& request) const;
 
  template <typename ModifyVpnConnectionRequestT = Model::ModifyVpnConnectionRequest>
  Model::ModifyVpnConnectionOutcomeCallable ModifyVpnConnectionCallable(const ModifyVpnConnectionRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpnConnection, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpnConnectionOptionsOutcome ModifyVpnConnectionOptions(
      const Model::ModifyVpnConnectionOptionsRequest& request) const;
 
  template <typename ModifyVpnConnectionOptionsRequestT = Model::ModifyVpnConnectionOptionsRequest>
  Model::ModifyVpnConnectionOptionsOutcomeCallable ModifyVpnConnectionOptionsCallable(
      const ModifyVpnConnectionOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpnConnectionOptions, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpnTunnelCertificateOutcome ModifyVpnTunnelCertificate(
      const Model::ModifyVpnTunnelCertificateRequest& request) const;
 
  template <typename ModifyVpnTunnelCertificateRequestT = Model::ModifyVpnTunnelCertificateRequest>
  Model::ModifyVpnTunnelCertificateOutcomeCallable ModifyVpnTunnelCertificateCallable(
      const ModifyVpnTunnelCertificateRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpnTunnelCertificate, request);
  }
 
  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);
  }
 
  virtual Model::ModifyVpnTunnelOptionsOutcome ModifyVpnTunnelOptions(const Model::ModifyVpnTunnelOptionsRequest& request) const;
 
  template <typename ModifyVpnTunnelOptionsRequestT = Model::ModifyVpnTunnelOptionsRequest>
  Model::ModifyVpnTunnelOptionsOutcomeCallable ModifyVpnTunnelOptionsCallable(const ModifyVpnTunnelOptionsRequestT& request) const {
    return SubmitCallable(&EC2Client::ModifyVpnTunnelOptions, request);
  }
 
  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);
  }
 
  virtual Model::MonitorInstancesOutcome MonitorInstances(const Model::MonitorInstancesRequest& request) const;
 
  template <typename MonitorInstancesRequestT = Model::MonitorInstancesRequest>
  Model::MonitorInstancesOutcomeCallable MonitorInstancesCallable(const MonitorInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::MonitorInstances, request);
  }
 
  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);
  }
 
  virtual Model::MoveAddressToVpcOutcome MoveAddressToVpc(const Model::MoveAddressToVpcRequest& request) const;
 
  template <typename MoveAddressToVpcRequestT = Model::MoveAddressToVpcRequest>
  Model::MoveAddressToVpcOutcomeCallable MoveAddressToVpcCallable(const MoveAddressToVpcRequestT& request) const {
    return SubmitCallable(&EC2Client::MoveAddressToVpc, request);
  }
 
  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);
  }
 
  virtual Model::MoveByoipCidrToIpamOutcome MoveByoipCidrToIpam(const Model::MoveByoipCidrToIpamRequest& request) const;
 
  template <typename MoveByoipCidrToIpamRequestT = Model::MoveByoipCidrToIpamRequest>
  Model::MoveByoipCidrToIpamOutcomeCallable MoveByoipCidrToIpamCallable(const MoveByoipCidrToIpamRequestT& request) const {
    return SubmitCallable(&EC2Client::MoveByoipCidrToIpam, request);
  }
 
  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);
  }
 
  virtual Model::MoveCapacityReservationInstancesOutcome MoveCapacityReservationInstances(
      const Model::MoveCapacityReservationInstancesRequest& request) const;
 
  template <typename MoveCapacityReservationInstancesRequestT = Model::MoveCapacityReservationInstancesRequest>
  Model::MoveCapacityReservationInstancesOutcomeCallable MoveCapacityReservationInstancesCallable(
      const MoveCapacityReservationInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::MoveCapacityReservationInstances, request);
  }
 
  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);
  }
 
  virtual Model::ProvisionByoipCidrOutcome ProvisionByoipCidr(const Model::ProvisionByoipCidrRequest& request) const;
 
  template <typename ProvisionByoipCidrRequestT = Model::ProvisionByoipCidrRequest>
  Model::ProvisionByoipCidrOutcomeCallable ProvisionByoipCidrCallable(const ProvisionByoipCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::ProvisionByoipCidr, request);
  }
 
  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);
  }
 
  virtual Model::ProvisionIpamByoasnOutcome ProvisionIpamByoasn(const Model::ProvisionIpamByoasnRequest& request) const;
 
  template <typename ProvisionIpamByoasnRequestT = Model::ProvisionIpamByoasnRequest>
  Model::ProvisionIpamByoasnOutcomeCallable ProvisionIpamByoasnCallable(const ProvisionIpamByoasnRequestT& request) const {
    return SubmitCallable(&EC2Client::ProvisionIpamByoasn, request);
  }
 
  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);
  }
 
  virtual Model::ProvisionIpamPoolCidrOutcome ProvisionIpamPoolCidr(const Model::ProvisionIpamPoolCidrRequest& request) const;
 
  template <typename ProvisionIpamPoolCidrRequestT = Model::ProvisionIpamPoolCidrRequest>
  Model::ProvisionIpamPoolCidrOutcomeCallable ProvisionIpamPoolCidrCallable(const ProvisionIpamPoolCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::ProvisionIpamPoolCidr, request);
  }
 
  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);
  }
 
  virtual Model::ProvisionPublicIpv4PoolCidrOutcome ProvisionPublicIpv4PoolCidr(
      const Model::ProvisionPublicIpv4PoolCidrRequest& request) const;
 
  template <typename ProvisionPublicIpv4PoolCidrRequestT = Model::ProvisionPublicIpv4PoolCidrRequest>
  Model::ProvisionPublicIpv4PoolCidrOutcomeCallable ProvisionPublicIpv4PoolCidrCallable(
      const ProvisionPublicIpv4PoolCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::ProvisionPublicIpv4PoolCidr, request);
  }
 
  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);
  }
 
  virtual Model::PurchaseCapacityBlockOutcome PurchaseCapacityBlock(const Model::PurchaseCapacityBlockRequest& request) const;
 
  template <typename PurchaseCapacityBlockRequestT = Model::PurchaseCapacityBlockRequest>
  Model::PurchaseCapacityBlockOutcomeCallable PurchaseCapacityBlockCallable(const PurchaseCapacityBlockRequestT& request) const {
    return SubmitCallable(&EC2Client::PurchaseCapacityBlock, request);
  }
 
  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);
  }
 
  virtual Model::PurchaseCapacityBlockExtensionOutcome PurchaseCapacityBlockExtension(
      const Model::PurchaseCapacityBlockExtensionRequest& request) const;
 
  template <typename PurchaseCapacityBlockExtensionRequestT = Model::PurchaseCapacityBlockExtensionRequest>
  Model::PurchaseCapacityBlockExtensionOutcomeCallable PurchaseCapacityBlockExtensionCallable(
      const PurchaseCapacityBlockExtensionRequestT& request) const {
    return SubmitCallable(&EC2Client::PurchaseCapacityBlockExtension, request);
  }
 
  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);
  }
 
  virtual Model::PurchaseHostReservationOutcome PurchaseHostReservation(const Model::PurchaseHostReservationRequest& request) const;
 
  template <typename PurchaseHostReservationRequestT = Model::PurchaseHostReservationRequest>
  Model::PurchaseHostReservationOutcomeCallable PurchaseHostReservationCallable(const PurchaseHostReservationRequestT& request) const {
    return SubmitCallable(&EC2Client::PurchaseHostReservation, request);
  }
 
  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);
  }
 
  virtual Model::PurchaseReservedInstancesOfferingOutcome PurchaseReservedInstancesOffering(
      const Model::PurchaseReservedInstancesOfferingRequest& request) const;
 
  template <typename PurchaseReservedInstancesOfferingRequestT = Model::PurchaseReservedInstancesOfferingRequest>
  Model::PurchaseReservedInstancesOfferingOutcomeCallable PurchaseReservedInstancesOfferingCallable(
      const PurchaseReservedInstancesOfferingRequestT& request) const {
    return SubmitCallable(&EC2Client::PurchaseReservedInstancesOffering, request);
  }
 
  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);
  }
 
  virtual Model::PurchaseScheduledInstancesOutcome PurchaseScheduledInstances(
      const Model::PurchaseScheduledInstancesRequest& request) const;
 
  template <typename PurchaseScheduledInstancesRequestT = Model::PurchaseScheduledInstancesRequest>
  Model::PurchaseScheduledInstancesOutcomeCallable PurchaseScheduledInstancesCallable(
      const PurchaseScheduledInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::PurchaseScheduledInstances, request);
  }
 
  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);
  }
 
  virtual Model::RebootInstancesOutcome RebootInstances(const Model::RebootInstancesRequest& request) const;
 
  template <typename RebootInstancesRequestT = Model::RebootInstancesRequest>
  Model::RebootInstancesOutcomeCallable RebootInstancesCallable(const RebootInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::RebootInstances, request);
  }
 
  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);
  }
 
  virtual Model::RegisterImageOutcome RegisterImage(const Model::RegisterImageRequest& request) const;
 
  template <typename RegisterImageRequestT = Model::RegisterImageRequest>
  Model::RegisterImageOutcomeCallable RegisterImageCallable(const RegisterImageRequestT& request) const {
    return SubmitCallable(&EC2Client::RegisterImage, request);
  }
 
  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);
  }
 
  virtual Model::RegisterInstanceEventNotificationAttributesOutcome RegisterInstanceEventNotificationAttributes(
      const Model::RegisterInstanceEventNotificationAttributesRequest& request) const;
 
  template <typename RegisterInstanceEventNotificationAttributesRequestT = Model::RegisterInstanceEventNotificationAttributesRequest>
  Model::RegisterInstanceEventNotificationAttributesOutcomeCallable RegisterInstanceEventNotificationAttributesCallable(
      const RegisterInstanceEventNotificationAttributesRequestT& request) const {
    return SubmitCallable(&EC2Client::RegisterInstanceEventNotificationAttributes, request);
  }
 
  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);
  }
 
  virtual Model::RegisterTransitGatewayMulticastGroupMembersOutcome RegisterTransitGatewayMulticastGroupMembers(
      const Model::RegisterTransitGatewayMulticastGroupMembersRequest& request) const;
 
  template <typename RegisterTransitGatewayMulticastGroupMembersRequestT = Model::RegisterTransitGatewayMulticastGroupMembersRequest>
  Model::RegisterTransitGatewayMulticastGroupMembersOutcomeCallable RegisterTransitGatewayMulticastGroupMembersCallable(
      const RegisterTransitGatewayMulticastGroupMembersRequestT& request) const {
    return SubmitCallable(&EC2Client::RegisterTransitGatewayMulticastGroupMembers, request);
  }
 
  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);
  }
 
  virtual Model::RegisterTransitGatewayMulticastGroupSourcesOutcome RegisterTransitGatewayMulticastGroupSources(
      const Model::RegisterTransitGatewayMulticastGroupSourcesRequest& request) const;
 
  template <typename RegisterTransitGatewayMulticastGroupSourcesRequestT = Model::RegisterTransitGatewayMulticastGroupSourcesRequest>
  Model::RegisterTransitGatewayMulticastGroupSourcesOutcomeCallable RegisterTransitGatewayMulticastGroupSourcesCallable(
      const RegisterTransitGatewayMulticastGroupSourcesRequestT& request) const {
    return SubmitCallable(&EC2Client::RegisterTransitGatewayMulticastGroupSources, request);
  }
 
  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);
  }
 
  virtual Model::RejectCapacityReservationBillingOwnershipOutcome RejectCapacityReservationBillingOwnership(
      const Model::RejectCapacityReservationBillingOwnershipRequest& request) const;
 
  template <typename RejectCapacityReservationBillingOwnershipRequestT = Model::RejectCapacityReservationBillingOwnershipRequest>
  Model::RejectCapacityReservationBillingOwnershipOutcomeCallable RejectCapacityReservationBillingOwnershipCallable(
      const RejectCapacityReservationBillingOwnershipRequestT& request) const {
    return SubmitCallable(&EC2Client::RejectCapacityReservationBillingOwnership, request);
  }
 
  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);
  }
 
  virtual Model::RejectTransitGatewayClientVpnAttachmentOutcome RejectTransitGatewayClientVpnAttachment(
      const Model::RejectTransitGatewayClientVpnAttachmentRequest& request) const;
 
  template <typename RejectTransitGatewayClientVpnAttachmentRequestT = Model::RejectTransitGatewayClientVpnAttachmentRequest>
  Model::RejectTransitGatewayClientVpnAttachmentOutcomeCallable RejectTransitGatewayClientVpnAttachmentCallable(
      const RejectTransitGatewayClientVpnAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::RejectTransitGatewayClientVpnAttachment, request);
  }
 
  template <typename RejectTransitGatewayClientVpnAttachmentRequestT = Model::RejectTransitGatewayClientVpnAttachmentRequest>
  void RejectTransitGatewayClientVpnAttachmentAsync(const RejectTransitGatewayClientVpnAttachmentRequestT& request,
                                                    const RejectTransitGatewayClientVpnAttachmentResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EC2Client::RejectTransitGatewayClientVpnAttachment, request, handler, context);
  }
 
  virtual Model::RejectTransitGatewayMulticastDomainAssociationsOutcome RejectTransitGatewayMulticastDomainAssociations(
      const Model::RejectTransitGatewayMulticastDomainAssociationsRequest& request = {}) const;
 
  template <
      typename RejectTransitGatewayMulticastDomainAssociationsRequestT = Model::RejectTransitGatewayMulticastDomainAssociationsRequest>
  Model::RejectTransitGatewayMulticastDomainAssociationsOutcomeCallable RejectTransitGatewayMulticastDomainAssociationsCallable(
      const RejectTransitGatewayMulticastDomainAssociationsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::RejectTransitGatewayMulticastDomainAssociations, request);
  }
 
  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);
  }
 
  virtual Model::RejectTransitGatewayPeeringAttachmentOutcome RejectTransitGatewayPeeringAttachment(
      const Model::RejectTransitGatewayPeeringAttachmentRequest& request) const;
 
  template <typename RejectTransitGatewayPeeringAttachmentRequestT = Model::RejectTransitGatewayPeeringAttachmentRequest>
  Model::RejectTransitGatewayPeeringAttachmentOutcomeCallable RejectTransitGatewayPeeringAttachmentCallable(
      const RejectTransitGatewayPeeringAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::RejectTransitGatewayPeeringAttachment, request);
  }
 
  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);
  }
 
  virtual Model::RejectTransitGatewayVpcAttachmentOutcome RejectTransitGatewayVpcAttachment(
      const Model::RejectTransitGatewayVpcAttachmentRequest& request) const;
 
  template <typename RejectTransitGatewayVpcAttachmentRequestT = Model::RejectTransitGatewayVpcAttachmentRequest>
  Model::RejectTransitGatewayVpcAttachmentOutcomeCallable RejectTransitGatewayVpcAttachmentCallable(
      const RejectTransitGatewayVpcAttachmentRequestT& request) const {
    return SubmitCallable(&EC2Client::RejectTransitGatewayVpcAttachment, request);
  }
 
  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);
  }
 
  virtual Model::RejectVpcEndpointConnectionsOutcome RejectVpcEndpointConnections(
      const Model::RejectVpcEndpointConnectionsRequest& request) const;
 
  template <typename RejectVpcEndpointConnectionsRequestT = Model::RejectVpcEndpointConnectionsRequest>
  Model::RejectVpcEndpointConnectionsOutcomeCallable RejectVpcEndpointConnectionsCallable(
      const RejectVpcEndpointConnectionsRequestT& request) const {
    return SubmitCallable(&EC2Client::RejectVpcEndpointConnections, request);
  }
 
  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);
  }
 
  virtual Model::RejectVpcPeeringConnectionOutcome RejectVpcPeeringConnection(
      const Model::RejectVpcPeeringConnectionRequest& request) const;
 
  template <typename RejectVpcPeeringConnectionRequestT = Model::RejectVpcPeeringConnectionRequest>
  Model::RejectVpcPeeringConnectionOutcomeCallable RejectVpcPeeringConnectionCallable(
      const RejectVpcPeeringConnectionRequestT& request) const {
    return SubmitCallable(&EC2Client::RejectVpcPeeringConnection, request);
  }
 
  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);
  }
 
  virtual Model::ReleaseAddressOutcome ReleaseAddress(const Model::ReleaseAddressRequest& request = {}) const;
 
  template <typename ReleaseAddressRequestT = Model::ReleaseAddressRequest>
  Model::ReleaseAddressOutcomeCallable ReleaseAddressCallable(const ReleaseAddressRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ReleaseAddress, request);
  }
 
  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);
  }
 
  virtual Model::ReleaseHostsOutcome ReleaseHosts(const Model::ReleaseHostsRequest& request) const;
 
  template <typename ReleaseHostsRequestT = Model::ReleaseHostsRequest>
  Model::ReleaseHostsOutcomeCallable ReleaseHostsCallable(const ReleaseHostsRequestT& request) const {
    return SubmitCallable(&EC2Client::ReleaseHosts, request);
  }
 
  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);
  }
 
  virtual Model::ReleaseIpamPoolAllocationOutcome ReleaseIpamPoolAllocation(const Model::ReleaseIpamPoolAllocationRequest& request) const;
 
  template <typename ReleaseIpamPoolAllocationRequestT = Model::ReleaseIpamPoolAllocationRequest>
  Model::ReleaseIpamPoolAllocationOutcomeCallable ReleaseIpamPoolAllocationCallable(
      const ReleaseIpamPoolAllocationRequestT& request) const {
    return SubmitCallable(&EC2Client::ReleaseIpamPoolAllocation, request);
  }
 
  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);
  }
 
  virtual Model::ReplaceIamInstanceProfileAssociationOutcome ReplaceIamInstanceProfileAssociation(
      const Model::ReplaceIamInstanceProfileAssociationRequest& request) const;
 
  template <typename ReplaceIamInstanceProfileAssociationRequestT = Model::ReplaceIamInstanceProfileAssociationRequest>
  Model::ReplaceIamInstanceProfileAssociationOutcomeCallable ReplaceIamInstanceProfileAssociationCallable(
      const ReplaceIamInstanceProfileAssociationRequestT& request) const {
    return SubmitCallable(&EC2Client::ReplaceIamInstanceProfileAssociation, request);
  }
 
  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);
  }
 
  virtual Model::ReplaceImageCriteriaInAllowedImagesSettingsOutcome ReplaceImageCriteriaInAllowedImagesSettings(
      const Model::ReplaceImageCriteriaInAllowedImagesSettingsRequest& request = {}) const;
 
  template <typename ReplaceImageCriteriaInAllowedImagesSettingsRequestT = Model::ReplaceImageCriteriaInAllowedImagesSettingsRequest>
  Model::ReplaceImageCriteriaInAllowedImagesSettingsOutcomeCallable ReplaceImageCriteriaInAllowedImagesSettingsCallable(
      const ReplaceImageCriteriaInAllowedImagesSettingsRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ReplaceImageCriteriaInAllowedImagesSettings, request);
  }
 
  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);
  }
 
  virtual Model::ReplaceNetworkAclAssociationOutcome ReplaceNetworkAclAssociation(
      const Model::ReplaceNetworkAclAssociationRequest& request) const;
 
  template <typename ReplaceNetworkAclAssociationRequestT = Model::ReplaceNetworkAclAssociationRequest>
  Model::ReplaceNetworkAclAssociationOutcomeCallable ReplaceNetworkAclAssociationCallable(
      const ReplaceNetworkAclAssociationRequestT& request) const {
    return SubmitCallable(&EC2Client::ReplaceNetworkAclAssociation, request);
  }
 
  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);
  }
 
  virtual Model::ReplaceNetworkAclEntryOutcome ReplaceNetworkAclEntry(const Model::ReplaceNetworkAclEntryRequest& request) const;
 
  template <typename ReplaceNetworkAclEntryRequestT = Model::ReplaceNetworkAclEntryRequest>
  Model::ReplaceNetworkAclEntryOutcomeCallable ReplaceNetworkAclEntryCallable(const ReplaceNetworkAclEntryRequestT& request) const {
    return SubmitCallable(&EC2Client::ReplaceNetworkAclEntry, request);
  }
 
  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);
  }
 
  virtual Model::ReplaceRouteOutcome ReplaceRoute(const Model::ReplaceRouteRequest& request) const;
 
  template <typename ReplaceRouteRequestT = Model::ReplaceRouteRequest>
  Model::ReplaceRouteOutcomeCallable ReplaceRouteCallable(const ReplaceRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::ReplaceRoute, request);
  }
 
  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);
  }
 
  virtual Model::ReplaceRouteTableAssociationOutcome ReplaceRouteTableAssociation(
      const Model::ReplaceRouteTableAssociationRequest& request) const;
 
  template <typename ReplaceRouteTableAssociationRequestT = Model::ReplaceRouteTableAssociationRequest>
  Model::ReplaceRouteTableAssociationOutcomeCallable ReplaceRouteTableAssociationCallable(
      const ReplaceRouteTableAssociationRequestT& request) const {
    return SubmitCallable(&EC2Client::ReplaceRouteTableAssociation, request);
  }
 
  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);
  }
 
  virtual Model::ReplaceTransitGatewayRouteOutcome ReplaceTransitGatewayRoute(
      const Model::ReplaceTransitGatewayRouteRequest& request) const;
 
  template <typename ReplaceTransitGatewayRouteRequestT = Model::ReplaceTransitGatewayRouteRequest>
  Model::ReplaceTransitGatewayRouteOutcomeCallable ReplaceTransitGatewayRouteCallable(
      const ReplaceTransitGatewayRouteRequestT& request) const {
    return SubmitCallable(&EC2Client::ReplaceTransitGatewayRoute, request);
  }
 
  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);
  }
 
  virtual Model::ReplaceVpnTunnelOutcome ReplaceVpnTunnel(const Model::ReplaceVpnTunnelRequest& request) const;
 
  template <typename ReplaceVpnTunnelRequestT = Model::ReplaceVpnTunnelRequest>
  Model::ReplaceVpnTunnelOutcomeCallable ReplaceVpnTunnelCallable(const ReplaceVpnTunnelRequestT& request) const {
    return SubmitCallable(&EC2Client::ReplaceVpnTunnel, request);
  }
 
  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);
  }
 
  virtual Model::ReportInstanceStatusOutcome ReportInstanceStatus(const Model::ReportInstanceStatusRequest& request) const;
 
  template <typename ReportInstanceStatusRequestT = Model::ReportInstanceStatusRequest>
  Model::ReportInstanceStatusOutcomeCallable ReportInstanceStatusCallable(const ReportInstanceStatusRequestT& request) const {
    return SubmitCallable(&EC2Client::ReportInstanceStatus, request);
  }
 
  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);
  }
 
  virtual Model::RequestSpotFleetOutcome RequestSpotFleet(const Model::RequestSpotFleetRequest& request) const;
 
  template <typename RequestSpotFleetRequestT = Model::RequestSpotFleetRequest>
  Model::RequestSpotFleetOutcomeCallable RequestSpotFleetCallable(const RequestSpotFleetRequestT& request) const {
    return SubmitCallable(&EC2Client::RequestSpotFleet, request);
  }
 
  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);
  }
 
  virtual Model::RequestSpotInstancesOutcome RequestSpotInstances(const Model::RequestSpotInstancesRequest& request = {}) const;
 
  template <typename RequestSpotInstancesRequestT = Model::RequestSpotInstancesRequest>
  Model::RequestSpotInstancesOutcomeCallable RequestSpotInstancesCallable(const RequestSpotInstancesRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::RequestSpotInstances, request);
  }
 
  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);
  }
 
  virtual Model::ResetAddressAttributeOutcome ResetAddressAttribute(const Model::ResetAddressAttributeRequest& request) const;
 
  template <typename ResetAddressAttributeRequestT = Model::ResetAddressAttributeRequest>
  Model::ResetAddressAttributeOutcomeCallable ResetAddressAttributeCallable(const ResetAddressAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ResetAddressAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ResetEbsDefaultKmsKeyIdOutcome ResetEbsDefaultKmsKeyId(const Model::ResetEbsDefaultKmsKeyIdRequest& request = {}) const;
 
  template <typename ResetEbsDefaultKmsKeyIdRequestT = Model::ResetEbsDefaultKmsKeyIdRequest>
  Model::ResetEbsDefaultKmsKeyIdOutcomeCallable ResetEbsDefaultKmsKeyIdCallable(const ResetEbsDefaultKmsKeyIdRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::ResetEbsDefaultKmsKeyId, request);
  }
 
  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);
  }
 
  virtual Model::ResetFpgaImageAttributeOutcome ResetFpgaImageAttribute(const Model::ResetFpgaImageAttributeRequest& request) const;
 
  template <typename ResetFpgaImageAttributeRequestT = Model::ResetFpgaImageAttributeRequest>
  Model::ResetFpgaImageAttributeOutcomeCallable ResetFpgaImageAttributeCallable(const ResetFpgaImageAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ResetFpgaImageAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ResetImageAttributeOutcome ResetImageAttribute(const Model::ResetImageAttributeRequest& request) const;
 
  template <typename ResetImageAttributeRequestT = Model::ResetImageAttributeRequest>
  Model::ResetImageAttributeOutcomeCallable ResetImageAttributeCallable(const ResetImageAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ResetImageAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ResetInstanceAttributeOutcome ResetInstanceAttribute(const Model::ResetInstanceAttributeRequest& request) const;
 
  template <typename ResetInstanceAttributeRequestT = Model::ResetInstanceAttributeRequest>
  Model::ResetInstanceAttributeOutcomeCallable ResetInstanceAttributeCallable(const ResetInstanceAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ResetInstanceAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ResetNetworkInterfaceAttributeOutcome ResetNetworkInterfaceAttribute(
      const Model::ResetNetworkInterfaceAttributeRequest& request) const;
 
  template <typename ResetNetworkInterfaceAttributeRequestT = Model::ResetNetworkInterfaceAttributeRequest>
  Model::ResetNetworkInterfaceAttributeOutcomeCallable ResetNetworkInterfaceAttributeCallable(
      const ResetNetworkInterfaceAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ResetNetworkInterfaceAttribute, request);
  }
 
  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);
  }
 
  virtual Model::ResetSnapshotAttributeOutcome ResetSnapshotAttribute(const Model::ResetSnapshotAttributeRequest& request) const;
 
  template <typename ResetSnapshotAttributeRequestT = Model::ResetSnapshotAttributeRequest>
  Model::ResetSnapshotAttributeOutcomeCallable ResetSnapshotAttributeCallable(const ResetSnapshotAttributeRequestT& request) const {
    return SubmitCallable(&EC2Client::ResetSnapshotAttribute, request);
  }
 
  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);
  }
 
  virtual Model::RestoreAddressToClassicOutcome RestoreAddressToClassic(const Model::RestoreAddressToClassicRequest& request) const;
 
  template <typename RestoreAddressToClassicRequestT = Model::RestoreAddressToClassicRequest>
  Model::RestoreAddressToClassicOutcomeCallable RestoreAddressToClassicCallable(const RestoreAddressToClassicRequestT& request) const {
    return SubmitCallable(&EC2Client::RestoreAddressToClassic, request);
  }
 
  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);
  }
 
  virtual Model::RestoreImageFromRecycleBinOutcome RestoreImageFromRecycleBin(
      const Model::RestoreImageFromRecycleBinRequest& request) const;
 
  template <typename RestoreImageFromRecycleBinRequestT = Model::RestoreImageFromRecycleBinRequest>
  Model::RestoreImageFromRecycleBinOutcomeCallable RestoreImageFromRecycleBinCallable(
      const RestoreImageFromRecycleBinRequestT& request) const {
    return SubmitCallable(&EC2Client::RestoreImageFromRecycleBin, request);
  }
 
  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);
  }
 
  virtual Model::RestoreManagedPrefixListVersionOutcome RestoreManagedPrefixListVersion(
      const Model::RestoreManagedPrefixListVersionRequest& request) const;
 
  template <typename RestoreManagedPrefixListVersionRequestT = Model::RestoreManagedPrefixListVersionRequest>
  Model::RestoreManagedPrefixListVersionOutcomeCallable RestoreManagedPrefixListVersionCallable(
      const RestoreManagedPrefixListVersionRequestT& request) const {
    return SubmitCallable(&EC2Client::RestoreManagedPrefixListVersion, request);
  }
 
  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);
  }
 
  virtual Model::RestoreSnapshotFromRecycleBinOutcome RestoreSnapshotFromRecycleBin(
      const Model::RestoreSnapshotFromRecycleBinRequest& request) const;
 
  template <typename RestoreSnapshotFromRecycleBinRequestT = Model::RestoreSnapshotFromRecycleBinRequest>
  Model::RestoreSnapshotFromRecycleBinOutcomeCallable RestoreSnapshotFromRecycleBinCallable(
      const RestoreSnapshotFromRecycleBinRequestT& request) const {
    return SubmitCallable(&EC2Client::RestoreSnapshotFromRecycleBin, request);
  }
 
  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);
  }
 
  virtual Model::RestoreSnapshotTierOutcome RestoreSnapshotTier(const Model::RestoreSnapshotTierRequest& request) const;
 
  template <typename RestoreSnapshotTierRequestT = Model::RestoreSnapshotTierRequest>
  Model::RestoreSnapshotTierOutcomeCallable RestoreSnapshotTierCallable(const RestoreSnapshotTierRequestT& request) const {
    return SubmitCallable(&EC2Client::RestoreSnapshotTier, request);
  }
 
  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);
  }
 
  virtual Model::RestoreVolumeFromRecycleBinOutcome RestoreVolumeFromRecycleBin(
      const Model::RestoreVolumeFromRecycleBinRequest& request) const;
 
  template <typename RestoreVolumeFromRecycleBinRequestT = Model::RestoreVolumeFromRecycleBinRequest>
  Model::RestoreVolumeFromRecycleBinOutcomeCallable RestoreVolumeFromRecycleBinCallable(
      const RestoreVolumeFromRecycleBinRequestT& request) const {
    return SubmitCallable(&EC2Client::RestoreVolumeFromRecycleBin, request);
  }
 
  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);
  }
 
  virtual Model::RevokeClientVpnIngressOutcome RevokeClientVpnIngress(const Model::RevokeClientVpnIngressRequest& request) const;
 
  template <typename RevokeClientVpnIngressRequestT = Model::RevokeClientVpnIngressRequest>
  Model::RevokeClientVpnIngressOutcomeCallable RevokeClientVpnIngressCallable(const RevokeClientVpnIngressRequestT& request) const {
    return SubmitCallable(&EC2Client::RevokeClientVpnIngress, request);
  }
 
  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);
  }
 
  virtual Model::RevokeSecurityGroupEgressOutcome RevokeSecurityGroupEgress(const Model::RevokeSecurityGroupEgressRequest& request) const;
 
  template <typename RevokeSecurityGroupEgressRequestT = Model::RevokeSecurityGroupEgressRequest>
  Model::RevokeSecurityGroupEgressOutcomeCallable RevokeSecurityGroupEgressCallable(
      const RevokeSecurityGroupEgressRequestT& request) const {
    return SubmitCallable(&EC2Client::RevokeSecurityGroupEgress, request);
  }
 
  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);
  }
 
  virtual Model::RevokeSecurityGroupIngressOutcome RevokeSecurityGroupIngress(
      const Model::RevokeSecurityGroupIngressRequest& request = {}) const;
 
  template <typename RevokeSecurityGroupIngressRequestT = Model::RevokeSecurityGroupIngressRequest>
  Model::RevokeSecurityGroupIngressOutcomeCallable RevokeSecurityGroupIngressCallable(
      const RevokeSecurityGroupIngressRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::RevokeSecurityGroupIngress, request);
  }
 
  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);
  }
 
  virtual Model::RunInstancesOutcome RunInstances(const Model::RunInstancesRequest& request) const;
 
  template <typename RunInstancesRequestT = Model::RunInstancesRequest>
  Model::RunInstancesOutcomeCallable RunInstancesCallable(const RunInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::RunInstances, request);
  }
 
  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);
  }
 
  virtual Model::RunScheduledInstancesOutcome RunScheduledInstances(const Model::RunScheduledInstancesRequest& request) const;
 
  template <typename RunScheduledInstancesRequestT = Model::RunScheduledInstancesRequest>
  Model::RunScheduledInstancesOutcomeCallable RunScheduledInstancesCallable(const RunScheduledInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::RunScheduledInstances, request);
  }
 
  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);
  }
 
  virtual Model::SearchLocalGatewayRoutesOutcome SearchLocalGatewayRoutes(const Model::SearchLocalGatewayRoutesRequest& request) const;
 
  template <typename SearchLocalGatewayRoutesRequestT = Model::SearchLocalGatewayRoutesRequest>
  Model::SearchLocalGatewayRoutesOutcomeCallable SearchLocalGatewayRoutesCallable(const SearchLocalGatewayRoutesRequestT& request) const {
    return SubmitCallable(&EC2Client::SearchLocalGatewayRoutes, request);
  }
 
  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);
  }
 
  virtual Model::SearchTransitGatewayMulticastGroupsOutcome SearchTransitGatewayMulticastGroups(
      const Model::SearchTransitGatewayMulticastGroupsRequest& request) const;
 
  template <typename SearchTransitGatewayMulticastGroupsRequestT = Model::SearchTransitGatewayMulticastGroupsRequest>
  Model::SearchTransitGatewayMulticastGroupsOutcomeCallable SearchTransitGatewayMulticastGroupsCallable(
      const SearchTransitGatewayMulticastGroupsRequestT& request) const {
    return SubmitCallable(&EC2Client::SearchTransitGatewayMulticastGroups, request);
  }
 
  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);
  }
 
  virtual Model::SearchTransitGatewayRoutesOutcome SearchTransitGatewayRoutes(
      const Model::SearchTransitGatewayRoutesRequest& request) const;
 
  template <typename SearchTransitGatewayRoutesRequestT = Model::SearchTransitGatewayRoutesRequest>
  Model::SearchTransitGatewayRoutesOutcomeCallable SearchTransitGatewayRoutesCallable(
      const SearchTransitGatewayRoutesRequestT& request) const {
    return SubmitCallable(&EC2Client::SearchTransitGatewayRoutes, request);
  }
 
  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);
  }
 
  virtual Model::SendDiagnosticInterruptOutcome SendDiagnosticInterrupt(const Model::SendDiagnosticInterruptRequest& request) const;
 
  template <typename SendDiagnosticInterruptRequestT = Model::SendDiagnosticInterruptRequest>
  Model::SendDiagnosticInterruptOutcomeCallable SendDiagnosticInterruptCallable(const SendDiagnosticInterruptRequestT& request) const {
    return SubmitCallable(&EC2Client::SendDiagnosticInterrupt, request);
  }
 
  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);
  }
 
  virtual Model::StartDeclarativePoliciesReportOutcome StartDeclarativePoliciesReport(
      const Model::StartDeclarativePoliciesReportRequest& request) const;
 
  template <typename StartDeclarativePoliciesReportRequestT = Model::StartDeclarativePoliciesReportRequest>
  Model::StartDeclarativePoliciesReportOutcomeCallable StartDeclarativePoliciesReportCallable(
      const StartDeclarativePoliciesReportRequestT& request) const {
    return SubmitCallable(&EC2Client::StartDeclarativePoliciesReport, request);
  }
 
  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);
  }
 
  virtual Model::StartInstancesOutcome StartInstances(const Model::StartInstancesRequest& request) const;
 
  template <typename StartInstancesRequestT = Model::StartInstancesRequest>
  Model::StartInstancesOutcomeCallable StartInstancesCallable(const StartInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::StartInstances, request);
  }
 
  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);
  }
 
  virtual Model::StartNetworkInsightsAccessScopeAnalysisOutcome StartNetworkInsightsAccessScopeAnalysis(
      const Model::StartNetworkInsightsAccessScopeAnalysisRequest& request) const;
 
  template <typename StartNetworkInsightsAccessScopeAnalysisRequestT = Model::StartNetworkInsightsAccessScopeAnalysisRequest>
  Model::StartNetworkInsightsAccessScopeAnalysisOutcomeCallable StartNetworkInsightsAccessScopeAnalysisCallable(
      const StartNetworkInsightsAccessScopeAnalysisRequestT& request) const {
    return SubmitCallable(&EC2Client::StartNetworkInsightsAccessScopeAnalysis, request);
  }
 
  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);
  }
 
  virtual Model::StartNetworkInsightsAnalysisOutcome StartNetworkInsightsAnalysis(
      const Model::StartNetworkInsightsAnalysisRequest& request) const;
 
  template <typename StartNetworkInsightsAnalysisRequestT = Model::StartNetworkInsightsAnalysisRequest>
  Model::StartNetworkInsightsAnalysisOutcomeCallable StartNetworkInsightsAnalysisCallable(
      const StartNetworkInsightsAnalysisRequestT& request) const {
    return SubmitCallable(&EC2Client::StartNetworkInsightsAnalysis, request);
  }
 
  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);
  }
 
  virtual Model::StartVpcEndpointServicePrivateDnsVerificationOutcome StartVpcEndpointServicePrivateDnsVerification(
      const Model::StartVpcEndpointServicePrivateDnsVerificationRequest& request) const;
 
  template <typename StartVpcEndpointServicePrivateDnsVerificationRequestT = Model::StartVpcEndpointServicePrivateDnsVerificationRequest>
  Model::StartVpcEndpointServicePrivateDnsVerificationOutcomeCallable StartVpcEndpointServicePrivateDnsVerificationCallable(
      const StartVpcEndpointServicePrivateDnsVerificationRequestT& request) const {
    return SubmitCallable(&EC2Client::StartVpcEndpointServicePrivateDnsVerification, request);
  }
 
  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);
  }
 
  virtual Model::StopInstancesOutcome StopInstances(const Model::StopInstancesRequest& request) const;
 
  template <typename StopInstancesRequestT = Model::StopInstancesRequest>
  Model::StopInstancesOutcomeCallable StopInstancesCallable(const StopInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::StopInstances, request);
  }
 
  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);
  }
 
  virtual Model::TerminateClientVpnConnectionsOutcome TerminateClientVpnConnections(
      const Model::TerminateClientVpnConnectionsRequest& request) const;
 
  template <typename TerminateClientVpnConnectionsRequestT = Model::TerminateClientVpnConnectionsRequest>
  Model::TerminateClientVpnConnectionsOutcomeCallable TerminateClientVpnConnectionsCallable(
      const TerminateClientVpnConnectionsRequestT& request) const {
    return SubmitCallable(&EC2Client::TerminateClientVpnConnections, request);
  }
 
  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);
  }
 
  virtual Model::TerminateInstancesOutcome TerminateInstances(const Model::TerminateInstancesRequest& request) const;
 
  template <typename TerminateInstancesRequestT = Model::TerminateInstancesRequest>
  Model::TerminateInstancesOutcomeCallable TerminateInstancesCallable(const TerminateInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::TerminateInstances, request);
  }
 
  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);
  }
 
  virtual Model::UnassignIpv6AddressesOutcome UnassignIpv6Addresses(const Model::UnassignIpv6AddressesRequest& request) const;
 
  template <typename UnassignIpv6AddressesRequestT = Model::UnassignIpv6AddressesRequest>
  Model::UnassignIpv6AddressesOutcomeCallable UnassignIpv6AddressesCallable(const UnassignIpv6AddressesRequestT& request) const {
    return SubmitCallable(&EC2Client::UnassignIpv6Addresses, request);
  }
 
  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);
  }
 
  virtual Model::UnassignPrivateIpAddressesOutcome UnassignPrivateIpAddresses(
      const Model::UnassignPrivateIpAddressesRequest& request) const;
 
  template <typename UnassignPrivateIpAddressesRequestT = Model::UnassignPrivateIpAddressesRequest>
  Model::UnassignPrivateIpAddressesOutcomeCallable UnassignPrivateIpAddressesCallable(
      const UnassignPrivateIpAddressesRequestT& request) const {
    return SubmitCallable(&EC2Client::UnassignPrivateIpAddresses, request);
  }
 
  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);
  }
 
  virtual Model::UnassignPrivateNatGatewayAddressOutcome UnassignPrivateNatGatewayAddress(
      const Model::UnassignPrivateNatGatewayAddressRequest& request) const;
 
  template <typename UnassignPrivateNatGatewayAddressRequestT = Model::UnassignPrivateNatGatewayAddressRequest>
  Model::UnassignPrivateNatGatewayAddressOutcomeCallable UnassignPrivateNatGatewayAddressCallable(
      const UnassignPrivateNatGatewayAddressRequestT& request) const {
    return SubmitCallable(&EC2Client::UnassignPrivateNatGatewayAddress, request);
  }
 
  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);
  }
 
  virtual Model::UnlockSnapshotOutcome UnlockSnapshot(const Model::UnlockSnapshotRequest& request) const;
 
  template <typename UnlockSnapshotRequestT = Model::UnlockSnapshotRequest>
  Model::UnlockSnapshotOutcomeCallable UnlockSnapshotCallable(const UnlockSnapshotRequestT& request) const {
    return SubmitCallable(&EC2Client::UnlockSnapshot, request);
  }
 
  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);
  }
 
  virtual Model::UnmonitorInstancesOutcome UnmonitorInstances(const Model::UnmonitorInstancesRequest& request) const;
 
  template <typename UnmonitorInstancesRequestT = Model::UnmonitorInstancesRequest>
  Model::UnmonitorInstancesOutcomeCallable UnmonitorInstancesCallable(const UnmonitorInstancesRequestT& request) const {
    return SubmitCallable(&EC2Client::UnmonitorInstances, request);
  }
 
  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);
  }
 
  virtual Model::UpdateCapacityManagerMonitoredTagKeysOutcome UpdateCapacityManagerMonitoredTagKeys(
      const Model::UpdateCapacityManagerMonitoredTagKeysRequest& request = {}) const;
 
  template <typename UpdateCapacityManagerMonitoredTagKeysRequestT = Model::UpdateCapacityManagerMonitoredTagKeysRequest>
  Model::UpdateCapacityManagerMonitoredTagKeysOutcomeCallable UpdateCapacityManagerMonitoredTagKeysCallable(
      const UpdateCapacityManagerMonitoredTagKeysRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::UpdateCapacityManagerMonitoredTagKeys, request);
  }
 
  template <typename UpdateCapacityManagerMonitoredTagKeysRequestT = Model::UpdateCapacityManagerMonitoredTagKeysRequest>
  void UpdateCapacityManagerMonitoredTagKeysAsync(const UpdateCapacityManagerMonitoredTagKeysResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const UpdateCapacityManagerMonitoredTagKeysRequestT& request = {}) const {
    return SubmitAsync(&EC2Client::UpdateCapacityManagerMonitoredTagKeys, request, handler, context);
  }
 
  virtual Model::UpdateCapacityManagerOrganizationsAccessOutcome UpdateCapacityManagerOrganizationsAccess(
      const Model::UpdateCapacityManagerOrganizationsAccessRequest& request) const;
 
  template <typename UpdateCapacityManagerOrganizationsAccessRequestT = Model::UpdateCapacityManagerOrganizationsAccessRequest>
  Model::UpdateCapacityManagerOrganizationsAccessOutcomeCallable UpdateCapacityManagerOrganizationsAccessCallable(
      const UpdateCapacityManagerOrganizationsAccessRequestT& request) const {
    return SubmitCallable(&EC2Client::UpdateCapacityManagerOrganizationsAccess, request);
  }
 
  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);
  }
 
  virtual Model::UpdateInterruptibleCapacityReservationAllocationOutcome UpdateInterruptibleCapacityReservationAllocation(
      const Model::UpdateInterruptibleCapacityReservationAllocationRequest& request) const;
 
  template <
      typename UpdateInterruptibleCapacityReservationAllocationRequestT = Model::UpdateInterruptibleCapacityReservationAllocationRequest>
  Model::UpdateInterruptibleCapacityReservationAllocationOutcomeCallable UpdateInterruptibleCapacityReservationAllocationCallable(
      const UpdateInterruptibleCapacityReservationAllocationRequestT& request) const {
    return SubmitCallable(&EC2Client::UpdateInterruptibleCapacityReservationAllocation, request);
  }
 
  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);
  }
 
  virtual Model::UpdateSecurityGroupRuleDescriptionsEgressOutcome UpdateSecurityGroupRuleDescriptionsEgress(
      const Model::UpdateSecurityGroupRuleDescriptionsEgressRequest& request = {}) const;
 
  template <typename UpdateSecurityGroupRuleDescriptionsEgressRequestT = Model::UpdateSecurityGroupRuleDescriptionsEgressRequest>
  Model::UpdateSecurityGroupRuleDescriptionsEgressOutcomeCallable UpdateSecurityGroupRuleDescriptionsEgressCallable(
      const UpdateSecurityGroupRuleDescriptionsEgressRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::UpdateSecurityGroupRuleDescriptionsEgress, request);
  }
 
  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);
  }
 
  virtual Model::UpdateSecurityGroupRuleDescriptionsIngressOutcome UpdateSecurityGroupRuleDescriptionsIngress(
      const Model::UpdateSecurityGroupRuleDescriptionsIngressRequest& request = {}) const;
 
  template <typename UpdateSecurityGroupRuleDescriptionsIngressRequestT = Model::UpdateSecurityGroupRuleDescriptionsIngressRequest>
  Model::UpdateSecurityGroupRuleDescriptionsIngressOutcomeCallable UpdateSecurityGroupRuleDescriptionsIngressCallable(
      const UpdateSecurityGroupRuleDescriptionsIngressRequestT& request = {}) const {
    return SubmitCallable(&EC2Client::UpdateSecurityGroupRuleDescriptionsIngress, request);
  }
 
  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);
  }
 
  virtual Model::WithdrawByoipCidrOutcome WithdrawByoipCidr(const Model::WithdrawByoipCidrRequest& request) const;
 
  template <typename WithdrawByoipCidrRequestT = Model::WithdrawByoipCidrRequest>
  Model::WithdrawByoipCidrOutcomeCallable WithdrawByoipCidrCallable(const WithdrawByoipCidrRequestT& request) const {
    return SubmitCallable(&EC2Client::WithdrawByoipCidr, request);
  }
 
  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