EC2Client.h

 
#pragma once
#include <aws/ec2/EC2_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/ec2/EC2ServiceClientModel.h>
 
namespace Aws
{
namespace EC2
{
  class AWS_EC2_API EC2Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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 AllocateHostsRequestT& request, const AllocateHostsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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::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::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::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::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::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 CreateDefaultSubnetRequestT& request, const CreateDefaultSubnetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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::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::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::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::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::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::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 CreateNatGatewayRequestT& request, const CreateNatGatewayResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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::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::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::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 CreateVolumeRequestT& request, const CreateVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<EC2EndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<EC2Client>;
        void init(const EC2ClientConfiguration& clientConfiguration);
 
        EC2ClientConfiguration m_clientConfiguration;
        std::shared_ptr<EC2EndpointProviderBase> m_endpointProvider;
  };
 
} // namespace EC2
} // namespace Aws