/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the ec2-2016-11-15.normal.json service model. */ using System; using System.Threading; using System.Threading.Tasks; using System.Collections.Generic; using Amazon.Runtime; using Amazon.EC2.Model; namespace Amazon.EC2 { ///

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

/// /// Amazon EC2: Amazon EC2 product page, Amazon /// EC2 documentation /// ///
/// /// Amazon EBS: Amazon EBS product page, Amazon /// EBS documentation /// ///
/// /// Amazon VPC: Amazon VPC product page, Amazon /// VPC documentation /// ///
/// /// VPN: VPN product page, VPN /// documentation /// ///

///

public partial interface IAmazonEC2 : IAmazonService, IDisposable { #if AWS_ASYNC_ENUMERABLES_API ///

/// Paginators for the service ///

IEC2PaginatorFactory Paginators { get; } #endif #region AcceptAddressTransfer ///

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

/// Container for the necessary parameters to execute the AcceptAddressTransfer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AcceptAddressTransfer service method, as returned by EC2. /// REST API Reference for AcceptAddressTransfer Operation Task AcceptAddressTransferAsync(AcceptAddressTransferRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AcceptReservedInstancesExchangeQuote ///

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

/// Container for the necessary parameters to execute the AcceptReservedInstancesExchangeQuote service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AcceptReservedInstancesExchangeQuote service method, as returned by EC2. /// REST API Reference for AcceptReservedInstancesExchangeQuote Operation Task AcceptReservedInstancesExchangeQuoteAsync(AcceptReservedInstancesExchangeQuoteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AcceptTransitGatewayMulticastDomainAssociations ///

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

/// Container for the necessary parameters to execute the AcceptTransitGatewayMulticastDomainAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AcceptTransitGatewayMulticastDomainAssociations service method, as returned by EC2. /// REST API Reference for AcceptTransitGatewayMulticastDomainAssociations Operation Task AcceptTransitGatewayMulticastDomainAssociationsAsync(AcceptTransitGatewayMulticastDomainAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AcceptTransitGatewayPeeringAttachment ///

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

/// Container for the necessary parameters to execute the AcceptTransitGatewayPeeringAttachment service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AcceptTransitGatewayPeeringAttachment service method, as returned by EC2. /// REST API Reference for AcceptTransitGatewayPeeringAttachment Operation Task AcceptTransitGatewayPeeringAttachmentAsync(AcceptTransitGatewayPeeringAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AcceptTransitGatewayVpcAttachment ///

/// Accepts a request to attach a VPC to a transit gateway. /// /// /// /// The VPC attachment must be in the pendingAcceptance state. Use DescribeTransitGatewayVpcAttachments /// to view your pending VPC attachment requests. Use RejectTransitGatewayVpcAttachment /// to reject a VPC attachment request. /// ///

/// Container for the necessary parameters to execute the AcceptTransitGatewayVpcAttachment service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AcceptTransitGatewayVpcAttachment service method, as returned by EC2. /// REST API Reference for AcceptTransitGatewayVpcAttachment Operation Task AcceptTransitGatewayVpcAttachmentAsync(AcceptTransitGatewayVpcAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AcceptVpcEndpointConnections ///

/// Accepts connection requests to your VPC endpoint service. ///

/// Container for the necessary parameters to execute the AcceptVpcEndpointConnections service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AcceptVpcEndpointConnections service method, as returned by EC2. /// REST API Reference for AcceptVpcEndpointConnections Operation Task AcceptVpcEndpointConnectionsAsync(AcceptVpcEndpointConnectionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AcceptVpcPeeringConnection ///

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

/// Container for the necessary parameters to execute the AcceptVpcPeeringConnection service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AcceptVpcPeeringConnection service method, as returned by EC2. /// REST API Reference for AcceptVpcPeeringConnection Operation Task AcceptVpcPeeringConnectionAsync(AcceptVpcPeeringConnectionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AdvertiseByoipCidr ///

/// Advertises an IPv4 or IPv6 address range that is provisioned for use with your Amazon /// Web Services resources through bring your own IP addresses (BYOIP). /// /// /// /// You can perform this operation at most once every 10 seconds, even if you specify /// different address ranges each time. /// /// /// /// We recommend that you stop advertising the BYOIP CIDR from other locations when you /// advertise it from Amazon Web Services. To minimize down time, you can configure your /// Amazon Web Services resources to use an address from a BYOIP CIDR before it is advertised, /// and then simultaneously stop advertising it from the current location and start advertising /// it through Amazon Web Services. /// /// /// /// It can take a few minutes before traffic to the specified addresses starts routing /// to Amazon Web Services because of BGP propagation delays. /// /// /// /// To stop advertising the BYOIP CIDR, use WithdrawByoipCidr. /// ///

/// Container for the necessary parameters to execute the AdvertiseByoipCidr service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AdvertiseByoipCidr service method, as returned by EC2. /// REST API Reference for AdvertiseByoipCidr Operation Task AdvertiseByoipCidrAsync(AdvertiseByoipCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AllocateAddress ///

/// Allocates an Elastic IP address to your Amazon Web Services account. After you allocate /// the Elastic IP address you can associate it with an instance or network interface. /// After you release an Elastic IP address, it is released to the IP address pool and /// can be allocated to a different Amazon Web Services account. /// /// /// /// You can allocate an Elastic IP address from an address pool owned by Amazon Web Services /// or from an address pool created from a public IPv4 address range that you have brought /// to Amazon Web Services for use with your Amazon Web Services resources using bring /// your own IP addresses (BYOIP). For more information, see Bring /// Your Own IP Addresses (BYOIP) in the Amazon Elastic Compute Cloud User Guide. /// /// /// /// If you release an Elastic IP address, you might be able to recover it. You cannot /// recover an Elastic IP address that you released after it is allocated to another Amazon /// Web Services account. To attempt to recover an Elastic IP address that you released, /// specify it in this operation. /// /// /// /// For more information, see Elastic /// IP Addresses in the Amazon Elastic Compute Cloud User Guide. /// /// /// /// You can allocate a carrier IP address which is a public IP address from a telecommunication /// carrier, to a network interface which resides in a subnet in a Wavelength Zone (for /// example an EC2 instance). /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AllocateAddress service method, as returned by EC2. /// REST API Reference for AllocateAddress Operation Task AllocateAddressAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the AllocateAddress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AllocateAddress service method, as returned by EC2. /// REST API Reference for AllocateAddress Operation Task AllocateAddressAsync(AllocateAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AllocateHosts ///

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

/// Container for the necessary parameters to execute the AllocateHosts service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AllocateHosts service method, as returned by EC2. /// REST API Reference for AllocateHosts Operation Task AllocateHostsAsync(AllocateHostsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AllocateIpamPoolCidr ///

/// Allocate a CIDR from an IPAM pool. The Region you use should be the IPAM pool locale. /// The locale is the Amazon Web Services Region where this IPAM pool is available for /// allocations. /// /// /// /// In IPAM, an allocation is a CIDR assignment from an IPAM pool to another IPAM pool /// or to a resource. For more information, see Allocate /// CIDRs in the Amazon VPC IPAM User Guide. /// /// /// /// This action creates an allocation with strong consistency. The returned CIDR will /// not overlap with any other allocations from the same pool. /// /// ///

/// Container for the necessary parameters to execute the AllocateIpamPoolCidr service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AllocateIpamPoolCidr service method, as returned by EC2. /// REST API Reference for AllocateIpamPoolCidr Operation Task AllocateIpamPoolCidrAsync(AllocateIpamPoolCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ApplySecurityGroupsToClientVpnTargetNetwork ///

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

/// Container for the necessary parameters to execute the ApplySecurityGroupsToClientVpnTargetNetwork service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ApplySecurityGroupsToClientVpnTargetNetwork service method, as returned by EC2. /// REST API Reference for ApplySecurityGroupsToClientVpnTargetNetwork Operation Task ApplySecurityGroupsToClientVpnTargetNetworkAsync(ApplySecurityGroupsToClientVpnTargetNetworkRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssignIpv6Addresses ///

/// Assigns one or more IPv6 addresses to the specified network interface. You can specify /// one or more specific IPv6 addresses, or you can specify the number of IPv6 addresses /// to be automatically assigned from within the subnet's IPv6 CIDR block range. You can /// assign as many IPv6 addresses to a network interface as you can assign private IPv4 /// addresses, and the limit varies per instance type. For information, see IP /// Addresses Per Network Interface Per Instance Type in the Amazon Elastic Compute /// Cloud User Guide. /// /// /// /// You must specify either the IPv6 addresses or the IPv6 address count in the request. /// /// /// /// /// You can optionally use Prefix Delegation on the network interface. You must specify /// either the IPV6 Prefix Delegation prefixes, or the IPv6 Prefix Delegation count. For /// information, see /// Assigning prefixes to Amazon EC2 network interfaces in the Amazon Elastic Compute /// Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the AssignIpv6Addresses service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssignIpv6Addresses service method, as returned by EC2. /// REST API Reference for AssignIpv6Addresses Operation Task AssignIpv6AddressesAsync(AssignIpv6AddressesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssignPrivateIpAddresses ///

/// Assigns one or more secondary private IP addresses to the specified network interface. /// /// /// /// You can specify one or more specific secondary IP addresses, or you can specify the /// number of secondary IP addresses to be automatically assigned within the subnet's /// CIDR block range. The number of secondary IP addresses that you can assign to an instance /// varies by instance type. For information about instance types, see Instance /// Types in the Amazon Elastic Compute Cloud User Guide. For more information /// about Elastic IP addresses, see Elastic /// IP Addresses in the Amazon Elastic Compute Cloud User Guide. /// /// /// /// When you move a secondary private IP address to another network interface, any Elastic /// IP address that is associated with the IP address is also moved. /// /// /// /// Remapping an IP address is an asynchronous operation. When you move an IP address /// from one network interface to another, check network/interfaces/macs/mac/local-ipv4s /// in the instance metadata to confirm that the remapping is complete. /// /// /// /// You must specify either the IP addresses or the IP address count in the request. /// /// /// /// You can optionally use Prefix Delegation on the network interface. You must specify /// either the IPv4 Prefix Delegation prefixes, or the IPv4 Prefix Delegation count. For /// information, see /// Assigning prefixes to Amazon EC2 network interfaces in the Amazon Elastic Compute /// Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the AssignPrivateIpAddresses service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssignPrivateIpAddresses service method, as returned by EC2. /// REST API Reference for AssignPrivateIpAddresses Operation Task AssignPrivateIpAddressesAsync(AssignPrivateIpAddressesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssignPrivateNatGatewayAddress ///

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

/// Container for the necessary parameters to execute the AssignPrivateNatGatewayAddress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssignPrivateNatGatewayAddress service method, as returned by EC2. /// REST API Reference for AssignPrivateNatGatewayAddress Operation Task AssignPrivateNatGatewayAddressAsync(AssignPrivateNatGatewayAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateAddress ///

/// Associates an Elastic IP address, or carrier IP address (for instances that are in /// subnets in Wavelength Zones) with an instance or a network interface. Before you can /// use an Elastic IP address, you must allocate it to your account. /// /// /// /// If the Elastic IP address is already associated with a different instance, it is disassociated /// from that instance and associated with the specified instance. If you associate an /// Elastic IP address with an instance that has an existing Elastic IP address, the existing /// address is disassociated from the instance, but remains allocated to your account. /// /// /// /// [Subnets in Wavelength Zones] You can associate an IP address from the telecommunication /// carrier to the instance or network interface. /// /// /// /// You cannot associate an Elastic IP address with an interface in a different network /// border group. /// /// /// /// This is an idempotent operation. If you perform the operation more than once, Amazon /// EC2 doesn't return an error, and you may be charged for each time the Elastic IP address /// is remapped to the same instance. For more information, see the Elastic IP Addresses /// section of Amazon EC2 Pricing. /// /// ///

/// Container for the necessary parameters to execute the AssociateAddress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateAddress service method, as returned by EC2. /// REST API Reference for AssociateAddress Operation Task AssociateAddressAsync(AssociateAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateClientVpnTargetNetwork ///

/// Associates a target network with a Client VPN endpoint. A target network is a subnet /// in a VPC. You can associate multiple subnets from the same VPC with a Client VPN endpoint. /// You can associate only one subnet in each Availability Zone. We recommend that you /// associate at least two subnets to provide Availability Zone redundancy. /// /// /// /// If you specified a VPC when you created the Client VPN endpoint or if you have previous /// subnet associations, the specified subnet must be in the same VPC. To specify a subnet /// that's in a different VPC, you must first modify the Client VPN endpoint (ModifyClientVpnEndpoint) /// and change the VPC that's associated with it. /// ///

/// Container for the necessary parameters to execute the AssociateClientVpnTargetNetwork service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateClientVpnTargetNetwork service method, as returned by EC2. /// REST API Reference for AssociateClientVpnTargetNetwork Operation Task AssociateClientVpnTargetNetworkAsync(AssociateClientVpnTargetNetworkRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateDhcpOptions ///

/// Associates a set of DHCP options (that you've previously created) with the specified /// VPC, or associates no DHCP options with the VPC. /// /// /// /// After you associate the options with the VPC, any existing instances and all new instances /// that you launch in that VPC use the options. You don't need to restart or relaunch /// the instances. They automatically pick up the changes within a few hours, depending /// on how frequently the instance renews its DHCP lease. You can explicitly renew the /// lease using the operating system on the instance. /// /// /// /// For more information, see DHCP /// options sets in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the AssociateDhcpOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateDhcpOptions service method, as returned by EC2. /// REST API Reference for AssociateDhcpOptions Operation Task AssociateDhcpOptionsAsync(AssociateDhcpOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateEnclaveCertificateIamRole ///

/// Associates an Identity and Access Management (IAM) role with an Certificate Manager /// (ACM) certificate. This enables the certificate to be used by the ACM for Nitro Enclaves /// application inside an enclave. For more information, see Certificate /// Manager for Nitro Enclaves in the Amazon Web Services Nitro Enclaves User Guide. /// /// /// /// When the IAM role is associated with the ACM certificate, the certificate, certificate /// chain, and encrypted private key are placed in an Amazon S3 location that only the /// associated IAM role can access. The private key of the certificate is encrypted with /// an Amazon Web Services managed key that has an attached attestation-based key policy. /// /// /// /// To enable the IAM role to access the Amazon S3 object, you must grant it permission /// to call s3:GetObject on the Amazon S3 bucket returned by the command. /// To enable the IAM role to access the KMS key, you must grant it permission to call /// kms:Decrypt on the KMS key returned by the command. For more information, /// see /// Grant the role permission to access the certificate and encryption key in the /// Amazon Web Services Nitro Enclaves User Guide. /// ///

/// Container for the necessary parameters to execute the AssociateEnclaveCertificateIamRole service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateEnclaveCertificateIamRole service method, as returned by EC2. /// REST API Reference for AssociateEnclaveCertificateIamRole Operation Task AssociateEnclaveCertificateIamRoleAsync(AssociateEnclaveCertificateIamRoleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateIamInstanceProfile ///

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

/// Container for the necessary parameters to execute the AssociateIamInstanceProfile service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateIamInstanceProfile service method, as returned by EC2. /// REST API Reference for AssociateIamInstanceProfile Operation Task AssociateIamInstanceProfileAsync(AssociateIamInstanceProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateInstanceEventWindow ///

/// Associates one or more targets with an event window. Only one type of target (instance /// IDs, Dedicated Host IDs, or tags) can be specified with an event window. /// /// /// /// For more information, see Define /// event windows for scheduled events in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the AssociateInstanceEventWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateInstanceEventWindow service method, as returned by EC2. /// REST API Reference for AssociateInstanceEventWindow Operation Task AssociateInstanceEventWindowAsync(AssociateInstanceEventWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateIpamResourceDiscovery ///

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

/// Container for the necessary parameters to execute the AssociateIpamResourceDiscovery service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateIpamResourceDiscovery service method, as returned by EC2. /// REST API Reference for AssociateIpamResourceDiscovery Operation Task AssociateIpamResourceDiscoveryAsync(AssociateIpamResourceDiscoveryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateNatGatewayAddress ///

/// Associates Elastic IP addresses (EIPs) and private IPv4 addresses with a public NAT /// gateway. For more information, see Work /// with NAT gateways in the Amazon VPC User Guide. /// /// /// /// By default, you can associate up to 2 Elastic IP addresses per public NAT gateway. /// You can increase the limit by requesting a quota adjustment. For more information, /// see Elastic /// IP address quotas in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the AssociateNatGatewayAddress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateNatGatewayAddress service method, as returned by EC2. /// REST API Reference for AssociateNatGatewayAddress Operation Task AssociateNatGatewayAddressAsync(AssociateNatGatewayAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateRouteTable ///

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

/// Container for the necessary parameters to execute the AssociateRouteTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateRouteTable service method, as returned by EC2. /// REST API Reference for AssociateRouteTable Operation Task AssociateRouteTableAsync(AssociateRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateSubnetCidrBlock ///

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

/// Container for the necessary parameters to execute the AssociateSubnetCidrBlock service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateSubnetCidrBlock service method, as returned by EC2. /// REST API Reference for AssociateSubnetCidrBlock Operation Task AssociateSubnetCidrBlockAsync(AssociateSubnetCidrBlockRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateTransitGatewayMulticastDomain ///

/// Associates the specified subnets and transit gateway attachments with the specified /// transit gateway multicast domain. /// /// /// /// The transit gateway attachment must be in the available state before you can add a /// resource. Use DescribeTransitGatewayAttachments /// to see the state of the attachment. /// ///

/// Container for the necessary parameters to execute the AssociateTransitGatewayMulticastDomain service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateTransitGatewayMulticastDomain service method, as returned by EC2. /// REST API Reference for AssociateTransitGatewayMulticastDomain Operation Task AssociateTransitGatewayMulticastDomainAsync(AssociateTransitGatewayMulticastDomainRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateTransitGatewayPolicyTable ///

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

/// Container for the necessary parameters to execute the AssociateTransitGatewayPolicyTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateTransitGatewayPolicyTable service method, as returned by EC2. /// REST API Reference for AssociateTransitGatewayPolicyTable Operation Task AssociateTransitGatewayPolicyTableAsync(AssociateTransitGatewayPolicyTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateTransitGatewayRouteTable ///

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

/// Container for the necessary parameters to execute the AssociateTransitGatewayRouteTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateTransitGatewayRouteTable service method, as returned by EC2. /// REST API Reference for AssociateTransitGatewayRouteTable Operation Task AssociateTransitGatewayRouteTableAsync(AssociateTransitGatewayRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateTrunkInterface ///

/// /// /// This API action is currently in limited preview only. If you are interested /// in using this feature, contact your account manager. /// /// /// /// Associates a branch network interface with a trunk network interface. /// /// /// /// Before you create the association, run the create-network-interface /// command and set --interface-type to trunk. You must also /// create a network interface for each branch network interface that you want to associate /// with the trunk network interface. /// ///

/// Container for the necessary parameters to execute the AssociateTrunkInterface service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateTrunkInterface service method, as returned by EC2. /// REST API Reference for AssociateTrunkInterface Operation Task AssociateTrunkInterfaceAsync(AssociateTrunkInterfaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AssociateVpcCidrBlock ///

/// Associates a CIDR block with your VPC. You can associate a secondary IPv4 CIDR block, /// an Amazon-provided IPv6 CIDR block, or an IPv6 CIDR block from an IPv6 address pool /// that you provisioned through bring your own IP addresses (BYOIP). /// The IPv6 CIDR block size is fixed at /56. /// /// /// /// You must specify one of the following in the request: an IPv4 CIDR block, an IPv6 /// pool, or an Amazon-provided IPv6 CIDR block. /// /// /// /// For more information about associating CIDR blocks with your VPC and applicable restrictions, /// see IP /// addressing for your VPCs and subnets in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the AssociateVpcCidrBlock service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateVpcCidrBlock service method, as returned by EC2. /// REST API Reference for AssociateVpcCidrBlock Operation Task AssociateVpcCidrBlockAsync(AssociateVpcCidrBlockRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AttachClassicLinkVpc ///

/// /// /// This action is deprecated. /// /// /// /// Links an EC2-Classic instance to a ClassicLink-enabled VPC through one or more of /// the VPC security groups. You cannot link an EC2-Classic instance to more than one /// VPC at a time. You can only link an instance that's in the running state. /// An instance is automatically unlinked from a VPC when it's stopped - you can link /// it to the VPC again when you restart it. /// /// /// /// After you've linked an instance, you cannot change the VPC security groups that are /// associated with it. To change the security groups, you must first unlink the instance, /// and then link it again. /// /// /// /// Linking your instance to a VPC is sometimes referred to as attaching your instance. /// ///

/// Container for the necessary parameters to execute the AttachClassicLinkVpc service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachClassicLinkVpc service method, as returned by EC2. /// REST API Reference for AttachClassicLinkVpc Operation Task AttachClassicLinkVpcAsync(AttachClassicLinkVpcRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AttachInternetGateway ///

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

/// Container for the necessary parameters to execute the AttachInternetGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachInternetGateway service method, as returned by EC2. /// REST API Reference for AttachInternetGateway Operation Task AttachInternetGatewayAsync(AttachInternetGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AttachNetworkInterface ///

/// Attaches a network interface to an instance. ///

/// Container for the necessary parameters to execute the AttachNetworkInterface service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachNetworkInterface service method, as returned by EC2. /// REST API Reference for AttachNetworkInterface Operation Task AttachNetworkInterfaceAsync(AttachNetworkInterfaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AttachVerifiedAccessTrustProvider ///

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

/// Container for the necessary parameters to execute the AttachVerifiedAccessTrustProvider service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachVerifiedAccessTrustProvider service method, as returned by EC2. /// REST API Reference for AttachVerifiedAccessTrustProvider Operation Task AttachVerifiedAccessTrustProviderAsync(AttachVerifiedAccessTrustProviderRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AttachVolume ///

/// Attaches an EBS volume to a running or stopped instance and exposes it to the instance /// with the specified device name. /// /// /// /// Encrypted EBS volumes must be attached to instances that support Amazon EBS encryption. /// For more information, see Amazon /// EBS encryption in the Amazon Elastic Compute Cloud User Guide. /// /// /// /// After you attach an EBS volume, you must make it available. For more information, /// see Make /// an EBS volume available for use. /// /// /// /// If a volume has an Amazon Web Services Marketplace product code: /// ///

/// /// The volume can be attached only to a stopped instance. /// ///
/// /// Amazon Web Services Marketplace product codes are copied from the volume to the instance. /// ///
/// /// You must be subscribed to the product. /// ///
/// /// The instance type and operating system of the instance must support the product. For /// example, you can't detach a volume from a Windows instance and attach it to a Linux /// instance. /// ///

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

/// Container for the necessary parameters to execute the AttachVolume service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachVolume service method, as returned by EC2. /// REST API Reference for AttachVolume Operation Task AttachVolumeAsync(AttachVolumeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AttachVpnGateway ///

/// Attaches a virtual private gateway to a VPC. You can attach one virtual private gateway /// to one VPC at a time. /// /// /// /// For more information, see Amazon /// Web Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN User /// Guide. /// ///

/// Container for the necessary parameters to execute the AttachVpnGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachVpnGateway service method, as returned by EC2. /// REST API Reference for AttachVpnGateway Operation Task AttachVpnGatewayAsync(AttachVpnGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AuthorizeClientVpnIngress ///

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

/// Container for the necessary parameters to execute the AuthorizeClientVpnIngress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AuthorizeClientVpnIngress service method, as returned by EC2. /// REST API Reference for AuthorizeClientVpnIngress Operation Task AuthorizeClientVpnIngressAsync(AuthorizeClientVpnIngressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AuthorizeSecurityGroupEgress ///

/// Adds the specified outbound (egress) rules to a security group for use with a VPC. /// /// /// /// An outbound rule permits instances to send traffic to the specified IPv4 or IPv6 CIDR /// address ranges, or to the instances that are associated with the specified source /// security groups. When specifying an outbound rule for your security group in a VPC, /// the IpPermissions must include a destination for the traffic. /// /// /// /// You specify a protocol for each rule (for example, TCP). For the TCP and UDP protocols, /// you must also specify the destination port or port range. For the ICMP protocol, you /// must also specify the ICMP type and code. You can use -1 for the type or code to mean /// all types or all codes. /// /// /// /// Rule changes are propagated to affected instances as quickly as possible. However, /// a small delay might occur. /// /// /// /// For information about VPC security group quotas, see Amazon /// VPC quotas. /// ///

/// Container for the necessary parameters to execute the AuthorizeSecurityGroupEgress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AuthorizeSecurityGroupEgress service method, as returned by EC2. /// REST API Reference for AuthorizeSecurityGroupEgress Operation Task AuthorizeSecurityGroupEgressAsync(AuthorizeSecurityGroupEgressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region AuthorizeSecurityGroupIngress ///

/// Adds the specified inbound (ingress) rules to a security group. /// /// /// /// An inbound rule permits instances to receive traffic from the specified IPv4 or IPv6 /// CIDR address range, or from the instances that are associated with the specified destination /// security groups. When specifying an inbound rule for your security group in a VPC, /// the IpPermissions must include a source for the traffic. /// /// /// /// You specify a protocol for each rule (for example, TCP). For TCP and UDP, you must /// also specify the destination port or port range. For ICMP/ICMPv6, you must also specify /// the ICMP/ICMPv6 type and code. You can use -1 to mean all types or all codes. /// /// /// /// Rule changes are propagated to instances within the security group as quickly as possible. /// However, a small delay might occur. /// /// /// /// For more information about VPC security group quotas, see Amazon /// VPC quotas. /// ///

/// Container for the necessary parameters to execute the AuthorizeSecurityGroupIngress service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AuthorizeSecurityGroupIngress service method, as returned by EC2. /// REST API Reference for AuthorizeSecurityGroupIngress Operation Task AuthorizeSecurityGroupIngressAsync(AuthorizeSecurityGroupIngressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region BundleInstance ///

/// Bundles an Amazon instance store-backed Windows instance. /// /// /// /// During bundling, only the root device volume (C:\) is bundled. Data on other instance /// store volumes is not preserved. /// /// /// /// This action is not applicable for Linux/Unix instances or Windows instances that are /// backed by Amazon EBS. /// /// ///

/// Container for the necessary parameters to execute the BundleInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the BundleInstance service method, as returned by EC2. /// REST API Reference for BundleInstance Operation Task BundleInstanceAsync(BundleInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelBundleTask ///

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

/// Container for the necessary parameters to execute the CancelBundleTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelBundleTask service method, as returned by EC2. /// REST API Reference for CancelBundleTask Operation Task CancelBundleTaskAsync(CancelBundleTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelCapacityReservation ///

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

/// Container for the necessary parameters to execute the CancelCapacityReservation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelCapacityReservation service method, as returned by EC2. /// REST API Reference for CancelCapacityReservation Operation Task CancelCapacityReservationAsync(CancelCapacityReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelCapacityReservationFleets ///

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

/// /// The Capacity Reservation Fleet's status changes to cancelled. /// ///
/// /// The individual Capacity Reservations in the Fleet are cancelled. Instances running /// in the Capacity Reservations at the time of cancelling the Fleet continue to run in /// shared capacity. /// ///
/// /// The Fleet stops creating new Capacity Reservations. /// ///

///

/// Container for the necessary parameters to execute the CancelCapacityReservationFleets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelCapacityReservationFleets service method, as returned by EC2. /// REST API Reference for CancelCapacityReservationFleets Operation Task CancelCapacityReservationFleetsAsync(CancelCapacityReservationFleetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelConversionTask ///

/// Cancels an active conversion task. The task can be the import of an instance or volume. /// The action removes all artifacts of the conversion, including a partially uploaded /// volume or instance. If the conversion is complete or is in the process of transferring /// the final disk image, the command fails and returns an exception. /// /// /// /// For more information, see Importing /// a Virtual Machine Using the Amazon EC2 CLI. /// ///

/// Container for the necessary parameters to execute the CancelConversionTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelConversionTask service method, as returned by EC2. /// REST API Reference for CancelConversionTask Operation Task CancelConversionTaskAsync(CancelConversionTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelExportTask ///

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

/// Container for the necessary parameters to execute the CancelExportTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelExportTask service method, as returned by EC2. /// REST API Reference for CancelExportTask Operation Task CancelExportTaskAsync(CancelExportTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelImageLaunchPermission ///

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

/// Container for the necessary parameters to execute the CancelImageLaunchPermission service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelImageLaunchPermission service method, as returned by EC2. /// REST API Reference for CancelImageLaunchPermission Operation Task CancelImageLaunchPermissionAsync(CancelImageLaunchPermissionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelImportTask ///

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

/// Container for the necessary parameters to execute the CancelImportTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelImportTask service method, as returned by EC2. /// REST API Reference for CancelImportTask Operation Task CancelImportTaskAsync(CancelImportTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelReservedInstancesListing ///

/// Cancels the specified Reserved Instance listing in the Reserved Instance Marketplace. /// /// /// /// For more information, see Reserved /// Instance Marketplace in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the CancelReservedInstancesListing service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelReservedInstancesListing service method, as returned by EC2. /// REST API Reference for CancelReservedInstancesListing Operation Task CancelReservedInstancesListingAsync(CancelReservedInstancesListingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelSpotFleetRequests ///

/// Cancels the specified Spot Fleet requests. /// /// /// /// After you cancel a Spot Fleet request, the Spot Fleet launches no new instances. /// /// /// /// You must also specify whether a canceled Spot Fleet request should terminate its instances. /// If you choose to terminate the instances, the Spot Fleet request enters the cancelled_terminating /// state. Otherwise, the Spot Fleet request enters the cancelled_running /// state and the instances continue to run until they are interrupted or you terminate /// them manually. /// ///

/// Container for the necessary parameters to execute the CancelSpotFleetRequests service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelSpotFleetRequests service method, as returned by EC2. /// REST API Reference for CancelSpotFleetRequests Operation Task CancelSpotFleetRequestsAsync(CancelSpotFleetRequestsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CancelSpotInstanceRequests ///

/// Cancels one or more Spot Instance requests. /// /// /// /// Canceling a Spot Instance request does not terminate running Spot Instances associated /// with the request. /// /// ///

/// Container for the necessary parameters to execute the CancelSpotInstanceRequests service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelSpotInstanceRequests service method, as returned by EC2. /// REST API Reference for CancelSpotInstanceRequests Operation Task CancelSpotInstanceRequestsAsync(CancelSpotInstanceRequestsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region ConfirmProductInstance ///

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

/// Container for the necessary parameters to execute the ConfirmProductInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ConfirmProductInstance service method, as returned by EC2. /// REST API Reference for ConfirmProductInstance Operation Task ConfirmProductInstanceAsync(ConfirmProductInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CopyFpgaImage ///

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

/// Container for the necessary parameters to execute the CopyFpgaImage service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CopyFpgaImage service method, as returned by EC2. /// REST API Reference for CopyFpgaImage Operation Task CopyFpgaImageAsync(CopyFpgaImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CopyImage ///

/// Initiates the copy of an AMI. You can copy an AMI from one Region to another, or from /// a Region to an Outpost. You can't copy an AMI from an Outpost to a Region, from one /// Outpost to another, or within the same Outpost. To copy an AMI to another partition, /// see CreateStoreImageTask. /// /// /// /// To copy an AMI from one Region to another, specify the source Region using the SourceRegion /// parameter, and specify the destination Region using its endpoint. Copies of encrypted /// backing snapshots for the AMI are encrypted. Copies of unencrypted backing snapshots /// remain unencrypted, unless you set Encrypted during the copy operation. /// You cannot create an unencrypted copy of an encrypted backing snapshot. /// /// /// /// To copy an AMI from a Region to an Outpost, specify the source Region using the SourceRegion /// parameter, and specify the ARN of the destination Outpost using DestinationOutpostArn. /// Backing snapshots copied to an Outpost are encrypted by default using the default /// encryption key for the Region, or a different key that you specify in the request /// using KmsKeyId. Outposts do not support unencrypted snapshots. For more information, /// /// Amazon EBS local snapshots on Outposts in the Amazon EC2 User Guide. /// /// /// /// For more information about the prerequisites and limits when copying an AMI, see Copy an /// AMI in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the CopyImage service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CopyImage service method, as returned by EC2. /// REST API Reference for CopyImage Operation Task CopyImageAsync(CopyImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CopySnapshot ///

/// Copies a point-in-time snapshot of an EBS volume and stores it in Amazon S3. You can /// copy a snapshot within the same Region, from one Region to another, or from a Region /// to an Outpost. You can't copy a snapshot from an Outpost to a Region, from one Outpost /// to another, or within the same Outpost. /// /// /// /// You can use the snapshot to create EBS volumes or Amazon Machine Images (AMIs). /// /// /// /// When copying snapshots to a Region, copies of encrypted EBS snapshots remain encrypted. /// Copies of unencrypted snapshots remain unencrypted, unless you enable encryption for /// the snapshot copy operation. By default, encrypted snapshot copies use the default /// Key Management Service (KMS) KMS key; however, you can specify a different KMS key. /// To copy an encrypted snapshot that has been shared from another account, you must /// have permissions for the KMS key used to encrypt the snapshot. /// /// /// /// Snapshots copied to an Outpost are encrypted by default using the default encryption /// key for the Region, or a different key that you specify in the request using KmsKeyId. /// Outposts do not support unencrypted snapshots. For more information, /// Amazon EBS local snapshots on Outposts in the Amazon Elastic Compute Cloud /// User Guide. /// /// /// /// Snapshots created by copying another snapshot have an arbitrary volume ID that should /// not be used for any purpose. /// /// /// /// For more information, see Copy /// an Amazon EBS snapshot in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CopySnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CopySnapshot service method, as returned by EC2. /// REST API Reference for CopySnapshot Operation Task CopySnapshotAsync(CopySnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateCapacityReservation ///

/// Creates a new Capacity Reservation with the specified attributes. /// /// /// /// Capacity Reservations enable you to reserve capacity for your Amazon EC2 instances /// in a specific Availability Zone for any duration. This gives you the flexibility to /// selectively add capacity reservations and still get the Regional RI discounts for /// that usage. By creating Capacity Reservations, you ensure that you always have access /// to Amazon EC2 capacity when you need it, for as long as you need it. For more information, /// see Capacity /// Reservations in the Amazon EC2 User Guide. /// /// /// /// Your request to create a Capacity Reservation could fail if Amazon EC2 does not have /// sufficient capacity to fulfill the request. If your request fails due to Amazon EC2 /// capacity constraints, either try again at a later time, try in a different Availability /// Zone, or request a smaller capacity reservation. If your application is flexible across /// instance types and sizes, try to create a Capacity Reservation with different instance /// attributes. /// /// /// /// Your request could also fail if the requested quantity exceeds your On-Demand Instance /// limit for the selected instance type. If your request fails due to limit constraints, /// increase your On-Demand Instance limit for the required instance type and try again. /// For more information about increasing your instance limits, see Amazon /// EC2 Service Quotas in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the CreateCapacityReservation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCapacityReservation service method, as returned by EC2. /// REST API Reference for CreateCapacityReservation Operation Task CreateCapacityReservationAsync(CreateCapacityReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateCapacityReservationFleet ///

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

/// Container for the necessary parameters to execute the CreateCapacityReservationFleet service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCapacityReservationFleet service method, as returned by EC2. /// REST API Reference for CreateCapacityReservationFleet Operation Task CreateCapacityReservationFleetAsync(CreateCapacityReservationFleetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateCarrierGateway ///

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

/// Container for the necessary parameters to execute the CreateCarrierGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCarrierGateway service method, as returned by EC2. /// REST API Reference for CreateCarrierGateway Operation Task CreateCarrierGatewayAsync(CreateCarrierGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateClientVpnEndpoint ///

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

/// Container for the necessary parameters to execute the CreateClientVpnEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateClientVpnEndpoint service method, as returned by EC2. /// REST API Reference for CreateClientVpnEndpoint Operation Task CreateClientVpnEndpointAsync(CreateClientVpnEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateClientVpnRoute ///

/// Adds a route to a network to a Client VPN endpoint. Each Client VPN endpoint has a /// route table that describes the available destination network routes. Each route in /// the route table specifies the path for traﬃc to speciﬁc resources or networks. ///

/// Container for the necessary parameters to execute the CreateClientVpnRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateClientVpnRoute service method, as returned by EC2. /// REST API Reference for CreateClientVpnRoute Operation Task CreateClientVpnRouteAsync(CreateClientVpnRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateCoipCidr ///

/// Creates a range of customer-owned IP addresses. ///

/// Container for the necessary parameters to execute the CreateCoipCidr service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCoipCidr service method, as returned by EC2. /// REST API Reference for CreateCoipCidr Operation Task CreateCoipCidrAsync(CreateCoipCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateCoipPool ///

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

/// Container for the necessary parameters to execute the CreateCoipPool service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCoipPool service method, as returned by EC2. /// REST API Reference for CreateCoipPool Operation Task CreateCoipPoolAsync(CreateCoipPoolRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateCustomerGateway ///

/// Provides information to Amazon Web Services about your customer gateway device. The /// customer gateway device is the appliance at your end of the VPN connection. You must /// provide the IP address of the customer gateway device’s external interface. The IP /// address must be static and can be behind a device performing network address translation /// (NAT). /// /// /// /// For devices that use Border Gateway Protocol (BGP), you can also provide the device's /// BGP Autonomous System Number (ASN). You can use an existing ASN assigned to your network. /// If you don't have an ASN already, you can use a private ASN. For more information, /// see Customer /// gateway options for your Site-to-Site VPN connection in the Amazon Web Services /// Site-to-Site VPN User Guide. /// /// /// /// To create more than one customer gateway with the same VPN type, IP address, and BGP /// ASN, specify a unique device name for each customer gateway. An identical request /// returns information about the existing customer gateway; it doesn't create a new customer /// gateway. /// ///

/// Container for the necessary parameters to execute the CreateCustomerGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCustomerGateway service method, as returned by EC2. /// REST API Reference for CreateCustomerGateway Operation Task CreateCustomerGatewayAsync(CreateCustomerGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateDefaultSubnet ///

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

/// Container for the necessary parameters to execute the CreateDefaultSubnet service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDefaultSubnet service method, as returned by EC2. /// REST API Reference for CreateDefaultSubnet Operation Task CreateDefaultSubnetAsync(CreateDefaultSubnetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateDefaultVpc ///

/// Creates a default VPC with a size /16 IPv4 CIDR block and a default subnet /// in each Availability Zone. For more information about the components of a default /// VPC, see Default /// VPCs in the Amazon VPC User Guide. You cannot specify the components of /// the default VPC yourself. /// /// /// /// If you deleted your previous default VPC, you can create a default VPC. You cannot /// have more than one default VPC per Region. /// ///

/// Container for the necessary parameters to execute the CreateDefaultVpc service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDefaultVpc service method, as returned by EC2. /// REST API Reference for CreateDefaultVpc Operation Task CreateDefaultVpcAsync(CreateDefaultVpcRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateDhcpOptions ///

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

/// /// domain-name-servers - The IP addresses of up to four domain name servers, /// or AmazonProvidedDNS. The default DHCP option set specifies AmazonProvidedDNS. If /// specifying more than one domain name server, specify the IP addresses in a single /// parameter, separated by commas. To have your instance receive a custom DNS hostname /// as specified in domain-name, you must set domain-name-servers /// to a custom DNS server. /// ///
/// /// domain-name - If you're using AmazonProvidedDNS in us-east-1, /// specify ec2.internal. If you're using AmazonProvidedDNS in another Region, /// specify region.compute.internal (for example, ap-northeast-1.compute.internal). /// Otherwise, specify a domain name (for example, ExampleCompany.com). This /// value is used to complete unqualified DNS hostnames. Important: Some Linux /// operating systems accept multiple domain names separated by spaces. However, Windows /// and other Linux operating systems treat the value as a single domain, which results /// in unexpected behavior. If your DHCP options set is associated with a VPC that has /// instances with multiple operating systems, specify only one domain name. /// ///
/// /// ntp-servers - The IP addresses of up to four Network Time Protocol (NTP) /// servers. /// ///
/// /// netbios-name-servers - The IP addresses of up to four NetBIOS name servers. /// ///
/// /// netbios-node-type - The NetBIOS node type (1, 2, 4, or 8). We recommend /// that you specify 2 (broadcast and multicast are not currently supported). For more /// information about these node types, see RFC /// 2132. /// ///

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

/// Container for the necessary parameters to execute the CreateDhcpOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDhcpOptions service method, as returned by EC2. /// REST API Reference for CreateDhcpOptions Operation Task CreateDhcpOptionsAsync(CreateDhcpOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateEgressOnlyInternetGateway ///

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

/// Container for the necessary parameters to execute the CreateEgressOnlyInternetGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateEgressOnlyInternetGateway service method, as returned by EC2. /// REST API Reference for CreateEgressOnlyInternetGateway Operation Task CreateEgressOnlyInternetGatewayAsync(CreateEgressOnlyInternetGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateFleet ///

/// Creates an EC2 Fleet that contains the configuration information for On-Demand Instances /// and Spot Instances. Instances are launched immediately if there is available capacity. /// /// /// /// A single EC2 Fleet can include multiple launch specifications that vary by instance /// type, AMI, Availability Zone, or subnet. /// /// /// /// For more information, see EC2 /// Fleet in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the CreateFleet service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateFleet service method, as returned by EC2. /// REST API Reference for CreateFleet Operation Task CreateFleetAsync(CreateFleetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateFlowLogs ///

/// Creates one or more flow logs to capture information about IP traffic for a specific /// network interface, subnet, or VPC. /// /// /// /// Flow log data for a monitored network interface is recorded as flow log records, which /// are log events consisting of fields that describe the traffic flow. For more information, /// see Flow /// log records in the Amazon Virtual Private Cloud User Guide. /// /// /// /// When publishing to CloudWatch Logs, flow log records are published to a log group, /// and each network interface has a unique log stream in the log group. When publishing /// to Amazon S3, flow log records for all of the monitored network interfaces are published /// to a single log file object that is stored in the specified bucket. /// /// /// /// For more information, see VPC /// Flow Logs in the Amazon Virtual Private Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateFlowLogs service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateFlowLogs service method, as returned by EC2. /// REST API Reference for CreateFlowLogs Operation Task CreateFlowLogsAsync(CreateFlowLogsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateFpgaImage ///

/// Creates an Amazon FPGA Image (AFI) from the specified design checkpoint (DCP). /// /// /// /// The create operation is asynchronous. To verify that the AFI is ready for use, check /// the output logs. /// /// /// /// An AFI contains the FPGA bitstream that is ready to download to an FPGA. You can securely /// deploy an AFI on multiple FPGA-accelerated instances. For more information, see the /// Amazon Web Services FPGA Hardware Development /// Kit. /// ///

/// Container for the necessary parameters to execute the CreateFpgaImage service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateFpgaImage service method, as returned by EC2. /// REST API Reference for CreateFpgaImage Operation Task CreateFpgaImageAsync(CreateFpgaImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateImage ///

/// Creates an Amazon EBS-backed AMI from an Amazon EBS-backed instance that is either /// running or stopped. /// /// /// /// If you customized your instance with instance store volumes or Amazon EBS volumes /// in addition to the root device volume, the new AMI contains block device mapping information /// for those volumes. When you launch an instance from this new AMI, the instance automatically /// launches with those additional volumes. /// /// /// /// For more information, see Create /// an Amazon EBS-backed Linux AMI in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateImage service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateImage service method, as returned by EC2. /// REST API Reference for CreateImage Operation Task CreateImageAsync(CreateImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateInstanceConnectEndpoint ///

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

/// Container for the necessary parameters to execute the CreateInstanceConnectEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateInstanceConnectEndpoint service method, as returned by EC2. /// REST API Reference for CreateInstanceConnectEndpoint Operation Task CreateInstanceConnectEndpointAsync(CreateInstanceConnectEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateInstanceEventWindow ///

/// Creates an event window in which scheduled events for the associated Amazon EC2 instances /// can run. /// /// /// /// You can define either a set of time ranges or a cron expression when creating the /// event window, but not both. All event window times are in UTC. /// /// /// /// You can create up to 200 event windows per Amazon Web Services Region. /// /// /// /// When you create the event window, targets (instance IDs, Dedicated Host IDs, or tags) /// are not yet associated with it. To ensure that the event window can be used, you must /// associate one or more targets with it by using the AssociateInstanceEventWindow /// API. /// /// /// /// Event windows are applicable only for scheduled events that stop, reboot, or terminate /// instances. /// /// /// /// Event windows are not applicable for: /// ///

/// /// Expedited scheduled events and network maintenance events. /// ///
/// /// Unscheduled maintenance such as AutoRecovery and unplanned reboots. /// ///

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

/// Container for the necessary parameters to execute the CreateInstanceEventWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateInstanceEventWindow service method, as returned by EC2. /// REST API Reference for CreateInstanceEventWindow Operation Task CreateInstanceEventWindowAsync(CreateInstanceEventWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateInstanceExportTask ///

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

/// Container for the necessary parameters to execute the CreateInstanceExportTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateInstanceExportTask service method, as returned by EC2. /// REST API Reference for CreateInstanceExportTask Operation Task CreateInstanceExportTaskAsync(CreateInstanceExportTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateInternetGateway ///

/// Creates an internet gateway for use with a VPC. After creating the internet gateway, /// you attach it to a VPC using AttachInternetGateway. /// /// /// /// For more information, see Internet /// gateways in the Amazon VPC User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateInternetGateway service method, as returned by EC2. /// REST API Reference for CreateInternetGateway Operation Task CreateInternetGatewayAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the CreateInternetGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateInternetGateway service method, as returned by EC2. /// REST API Reference for CreateInternetGateway Operation Task CreateInternetGatewayAsync(CreateInternetGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateIpam ///

/// Create an IPAM. Amazon VPC IP Address Manager (IPAM) is a VPC feature that you can /// use to automate your IP address management workflows including assigning, tracking, /// troubleshooting, and auditing IP addresses across Amazon Web Services Regions and /// accounts throughout your Amazon Web Services Organization. /// /// /// /// For more information, see Create /// an IPAM in the Amazon VPC IPAM User Guide. /// ///

/// Container for the necessary parameters to execute the CreateIpam service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateIpam service method, as returned by EC2. /// REST API Reference for CreateIpam Operation Task CreateIpamAsync(CreateIpamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateIpamPool ///

/// Create an IP address pool for Amazon VPC IP Address Manager (IPAM). In IPAM, a pool /// is a collection of contiguous IP addresses CIDRs. Pools enable you to organize your /// IP addresses according to your routing and security needs. For example, if you have /// separate routing and security needs for development and production applications, you /// can create a pool for each. /// /// /// /// For more information, see Create /// a top-level pool in the Amazon VPC IPAM User Guide. /// ///

/// Container for the necessary parameters to execute the CreateIpamPool service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateIpamPool service method, as returned by EC2. /// REST API Reference for CreateIpamPool Operation Task CreateIpamPoolAsync(CreateIpamPoolRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateIpamResourceDiscovery ///

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

/// Container for the necessary parameters to execute the CreateIpamResourceDiscovery service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateIpamResourceDiscovery service method, as returned by EC2. /// REST API Reference for CreateIpamResourceDiscovery Operation Task CreateIpamResourceDiscoveryAsync(CreateIpamResourceDiscoveryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateIpamScope ///

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

/// Container for the necessary parameters to execute the CreateIpamScope service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateIpamScope service method, as returned by EC2. /// REST API Reference for CreateIpamScope Operation Task CreateIpamScopeAsync(CreateIpamScopeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateKeyPair ///

/// Creates an ED25519 or 2048-bit RSA key pair with the specified name and in the specified /// PEM or PPK format. Amazon EC2 stores the public key and displays the private key for /// you to save to a file. The private key is returned as an unencrypted PEM encoded PKCS#1 /// private key or an unencrypted PPK formatted private key for use with PuTTY. If a key /// with the specified name already exists, Amazon EC2 returns an error. /// /// /// /// The key pair returned to you is available only in the Amazon Web Services Region in /// which you create it. If you prefer, you can create your own key pair using a third-party /// tool and upload it to any Region using ImportKeyPair. /// /// /// /// You can have up to 5,000 key pairs per Amazon Web Services Region. /// /// /// /// For more information, see Amazon /// EC2 key pairs in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateKeyPair service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateKeyPair service method, as returned by EC2. /// REST API Reference for CreateKeyPair Operation Task CreateKeyPairAsync(CreateKeyPairRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLaunchTemplate ///

/// Creates a launch template. /// /// /// /// A launch template contains the parameters to launch an instance. When you launch an /// instance using RunInstances, you can specify a launch template instead of providing /// the launch parameters in the request. For more information, see Launch /// an instance from a launch template in the Amazon Elastic Compute Cloud User /// Guide. /// /// /// /// If you want to clone an existing launch template as the basis for creating a new launch /// template, you can use the Amazon EC2 console. The API, SDKs, and CLI do not support /// cloning a template. For more information, see Create /// a launch template from an existing launch template in the Amazon Elastic Compute /// Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateLaunchTemplate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLaunchTemplate service method, as returned by EC2. /// REST API Reference for CreateLaunchTemplate Operation Task CreateLaunchTemplateAsync(CreateLaunchTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLaunchTemplateVersion ///

/// Creates a new version of a launch template. You can specify an existing version of /// launch template from which to base the new version. /// /// /// /// Launch template versions are numbered in the order in which they are created. You /// cannot specify, change, or replace the numbering of launch template versions. /// /// /// /// Launch templates are immutable; after you create a launch template, you can't modify /// it. Instead, you can create a new version of the launch template that includes any /// changes you require. /// /// /// /// For more information, see Modify /// a launch template (manage launch template versions) in the Amazon Elastic Compute /// Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateLaunchTemplateVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLaunchTemplateVersion service method, as returned by EC2. /// REST API Reference for CreateLaunchTemplateVersion Operation Task CreateLaunchTemplateVersionAsync(CreateLaunchTemplateVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLocalGatewayRoute ///

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

/// /// LocalGatewayVirtualInterfaceGroupId /// ///
/// /// NetworkInterfaceId /// ///

///

/// Container for the necessary parameters to execute the CreateLocalGatewayRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLocalGatewayRoute service method, as returned by EC2. /// REST API Reference for CreateLocalGatewayRoute Operation Task CreateLocalGatewayRouteAsync(CreateLocalGatewayRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLocalGatewayRouteTable ///

/// Creates a local gateway route table. ///

/// Container for the necessary parameters to execute the CreateLocalGatewayRouteTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLocalGatewayRouteTable service method, as returned by EC2. /// REST API Reference for CreateLocalGatewayRouteTable Operation Task CreateLocalGatewayRouteTableAsync(CreateLocalGatewayRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation ///

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

/// Container for the necessary parameters to execute the CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation service method, as returned by EC2. /// REST API Reference for CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation Operation Task CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationAsync(CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateLocalGatewayRouteTableVpcAssociation ///

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

/// Container for the necessary parameters to execute the CreateLocalGatewayRouteTableVpcAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateLocalGatewayRouteTableVpcAssociation service method, as returned by EC2. /// REST API Reference for CreateLocalGatewayRouteTableVpcAssociation Operation Task CreateLocalGatewayRouteTableVpcAssociationAsync(CreateLocalGatewayRouteTableVpcAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateManagedPrefixList ///

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

/// Container for the necessary parameters to execute the CreateManagedPrefixList service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateManagedPrefixList service method, as returned by EC2. /// REST API Reference for CreateManagedPrefixList Operation Task CreateManagedPrefixListAsync(CreateManagedPrefixListRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateNatGateway ///

/// Creates a NAT gateway in the specified subnet. This action creates a network interface /// in the specified subnet with a private IP address from the IP address range of the /// subnet. You can create either a public NAT gateway or a private NAT gateway. /// /// /// /// With a public NAT gateway, internet-bound traffic from a private subnet can be routed /// to the NAT gateway, so that instances in a private subnet can connect to the internet. /// /// /// /// With a private NAT gateway, private communication is routed across VPCs and on-premises /// networks through a transit gateway or virtual private gateway. Common use cases include /// running large workloads behind a small pool of allowlisted IPv4 addresses, preserving /// private IPv4 addresses, and communicating between overlapping networks. /// /// /// /// For more information, see NAT /// gateways in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the CreateNatGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateNatGateway service method, as returned by EC2. /// REST API Reference for CreateNatGateway Operation Task CreateNatGatewayAsync(CreateNatGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateNetworkAcl ///

/// Creates a network ACL in a VPC. Network ACLs provide an optional layer of security /// (in addition to security groups) for the instances in your VPC. /// /// /// /// For more information, see Network /// ACLs in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the CreateNetworkAcl service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateNetworkAcl service method, as returned by EC2. /// REST API Reference for CreateNetworkAcl Operation Task CreateNetworkAclAsync(CreateNetworkAclRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateNetworkAclEntry ///

/// Creates an entry (a rule) in a network ACL with the specified rule number. Each network /// ACL has a set of numbered ingress rules and a separate set of numbered egress rules. /// When determining whether a packet should be allowed in or out of a subnet associated /// with the ACL, we process the entries in the ACL according to the rule numbers, in /// ascending order. Each network ACL has a set of ingress rules and a separate set of /// egress rules. /// /// /// /// We recommend that you leave room between the rule numbers (for example, 100, 110, /// 120, ...), and not number them one right after the other (for example, 101, 102, 103, /// ...). This makes it easier to add a rule between existing ones without having to renumber /// the rules. /// /// /// /// After you add an entry, you can't modify it; you must either replace it, or create /// an entry and delete the old one. /// /// /// /// For more information about network ACLs, see Network /// ACLs in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the CreateNetworkAclEntry service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateNetworkAclEntry service method, as returned by EC2. /// REST API Reference for CreateNetworkAclEntry Operation Task CreateNetworkAclEntryAsync(CreateNetworkAclEntryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateNetworkInsightsAccessScope ///

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

/// Container for the necessary parameters to execute the CreateNetworkInsightsAccessScope service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateNetworkInsightsAccessScope service method, as returned by EC2. /// REST API Reference for CreateNetworkInsightsAccessScope Operation Task CreateNetworkInsightsAccessScopeAsync(CreateNetworkInsightsAccessScopeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateNetworkInsightsPath ///

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

/// Container for the necessary parameters to execute the CreateNetworkInsightsPath service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateNetworkInsightsPath service method, as returned by EC2. /// REST API Reference for CreateNetworkInsightsPath Operation Task CreateNetworkInsightsPathAsync(CreateNetworkInsightsPathRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateNetworkInterface ///

/// Creates a network interface in the specified subnet. /// /// /// /// The number of IP addresses you can assign to a network interface varies by instance /// type. For more information, see IP /// Addresses Per ENI Per Instance Type in the Amazon Virtual Private Cloud User /// Guide. /// /// /// /// For more information about network interfaces, see Elastic /// network interfaces in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateNetworkInterface service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateNetworkInterface service method, as returned by EC2. /// REST API Reference for CreateNetworkInterface Operation Task CreateNetworkInterfaceAsync(CreateNetworkInterfaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateNetworkInterfacePermission ///

/// Grants an Amazon Web Services-authorized account permission to attach the specified /// network interface to an instance in their account. /// /// /// /// You can grant permission to a single Amazon Web Services account only, and only one /// account at a time. /// ///

/// Container for the necessary parameters to execute the CreateNetworkInterfacePermission service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateNetworkInterfacePermission service method, as returned by EC2. /// REST API Reference for CreateNetworkInterfacePermission Operation Task CreateNetworkInterfacePermissionAsync(CreateNetworkInterfacePermissionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreatePlacementGroup ///

/// Creates a placement group in which to launch instances. The strategy of the placement /// group determines how the instances are organized within the group. /// /// /// /// A cluster placement group is a logical grouping of instances within a /// single Availability Zone that benefit from low network latency, high network throughput. /// A spread placement group places instances on distinct hardware. A partition /// placement group places groups of instances in different partitions, where instances /// in one partition do not share the same hardware with instances in another partition. /// /// /// /// For more information, see Placement /// groups in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the CreatePlacementGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePlacementGroup service method, as returned by EC2. /// REST API Reference for CreatePlacementGroup Operation Task CreatePlacementGroupAsync(CreatePlacementGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreatePublicIpv4Pool ///

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

/// Container for the necessary parameters to execute the CreatePublicIpv4Pool service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePublicIpv4Pool service method, as returned by EC2. /// REST API Reference for CreatePublicIpv4Pool Operation Task CreatePublicIpv4PoolAsync(CreatePublicIpv4PoolRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateReplaceRootVolumeTask ///

/// Replaces the EBS-backed root volume for a running instance with a new /// volume that is restored to the original root volume's launch state, that is restored /// to a specific snapshot taken from the original root volume, or that is restored from /// an AMI that has the same key characteristics as that of the instance. /// /// /// /// For more information, see Replace /// a root volume in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateReplaceRootVolumeTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateReplaceRootVolumeTask service method, as returned by EC2. /// REST API Reference for CreateReplaceRootVolumeTask Operation Task CreateReplaceRootVolumeTaskAsync(CreateReplaceRootVolumeTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateReservedInstancesListing ///

/// Creates a listing for Amazon EC2 Standard Reserved Instances to be sold in the Reserved /// Instance Marketplace. You can submit one Standard Reserved Instance listing at a time. /// To get a list of your Standard Reserved Instances, you can use the DescribeReservedInstances /// operation. /// /// /// /// Only Standard Reserved Instances can be sold in the Reserved Instance Marketplace. /// Convertible Reserved Instances cannot be sold. /// /// /// /// The Reserved Instance Marketplace matches sellers who want to resell Standard Reserved /// Instance capacity that they no longer need with buyers who want to purchase additional /// capacity. Reserved Instances bought and sold through the Reserved Instance Marketplace /// work like any other Reserved Instances. /// /// /// /// To sell your Standard Reserved Instances, you must first register as a seller in the /// Reserved Instance Marketplace. After completing the registration process, you can /// create a Reserved Instance Marketplace listing of some or all of your Standard Reserved /// Instances, and specify the upfront price to receive for them. Your Standard Reserved /// Instance listings then become available for purchase. To view the details of your /// Standard Reserved Instance listing, you can use the DescribeReservedInstancesListings /// operation. /// /// /// /// For more information, see Reserved /// Instance Marketplace in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the CreateReservedInstancesListing service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateReservedInstancesListing service method, as returned by EC2. /// REST API Reference for CreateReservedInstancesListing Operation Task CreateReservedInstancesListingAsync(CreateReservedInstancesListingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateRestoreImageTask ///

/// Starts a task that restores an AMI from an Amazon S3 object that was previously created /// by using CreateStoreImageTask. /// /// /// /// To use this API, you must have the required permissions. For more information, see /// Permissions /// for storing and restoring AMIs using Amazon S3 in the Amazon EC2 User Guide. /// /// /// /// For more information, see Store /// and restore an AMI using Amazon S3 in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the CreateRestoreImageTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateRestoreImageTask service method, as returned by EC2. /// REST API Reference for CreateRestoreImageTask Operation Task CreateRestoreImageTaskAsync(CreateRestoreImageTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateRoute ///

/// Creates a route in a route table within a VPC. /// /// /// /// You must specify either a destination CIDR block or a prefix list ID. You must also /// specify exactly one of the resources from the parameter list. /// /// /// /// When determining how to route traffic, we use the route with the most specific match. /// For example, traffic is destined for the IPv4 address 192.0.2.3, and /// the route table includes the following two IPv4 routes: /// ///

/// /// 192.0.2.0/24 (goes to some target A) /// ///
/// /// 192.0.2.0/28 (goes to some target B) /// ///

/// /// Both routes apply to the traffic destined for 192.0.2.3. However, the /// second route in the list covers a smaller number of IP addresses and is therefore /// more specific, so we use that route to determine where to target the traffic. /// /// /// /// For more information about route tables, see Route /// tables in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the CreateRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateRoute service method, as returned by EC2. /// REST API Reference for CreateRoute Operation Task CreateRouteAsync(CreateRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateRouteTable ///

/// Creates a route table for the specified VPC. After you create a route table, you can /// add routes and associate the table with a subnet. /// /// /// /// For more information, see Route /// tables in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the CreateRouteTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateRouteTable service method, as returned by EC2. /// REST API Reference for CreateRouteTable Operation Task CreateRouteTableAsync(CreateRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateSecurityGroup ///

/// Creates a security group. /// /// /// /// A security group acts as a virtual firewall for your instance to control inbound and /// outbound traffic. For more information, see Amazon /// EC2 security groups in the Amazon Elastic Compute Cloud User Guide and /// Security /// groups for your VPC in the Amazon Virtual Private Cloud User Guide. /// /// /// /// When you create a security group, you specify a friendly name of your choice. You /// can't have two security groups for the same VPC with the same name. /// /// /// /// You have a default security group for use in your VPC. If you don't specify a security /// group when you launch an instance, the instance is launched into the appropriate default /// security group. A default security group includes a default rule that grants instances /// unrestricted network access to each other. /// /// /// /// You can add or remove rules from your security groups using AuthorizeSecurityGroupIngress, /// AuthorizeSecurityGroupEgress, RevokeSecurityGroupIngress, and RevokeSecurityGroupEgress. /// /// /// /// For more information about VPC security group limits, see Amazon /// VPC Limits. /// ///

/// Container for the necessary parameters to execute the CreateSecurityGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSecurityGroup service method, as returned by EC2. /// REST API Reference for CreateSecurityGroup Operation Task CreateSecurityGroupAsync(CreateSecurityGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateSnapshot ///

/// Creates a snapshot of an EBS volume and stores it in Amazon S3. You can use snapshots /// for backups, to make copies of EBS volumes, and to save data before shutting down /// an instance. /// /// /// /// You can create snapshots of volumes in a Region and volumes on an Outpost. If you /// create a snapshot of a volume in a Region, the snapshot must be stored in the same /// Region as the volume. If you create a snapshot of a volume on an Outpost, the snapshot /// can be stored on the same Outpost as the volume, or in the Region for that Outpost. /// /// /// /// When a snapshot is created, any Amazon Web Services Marketplace product codes that /// are associated with the source volume are propagated to the snapshot. /// /// /// /// You can take a snapshot of an attached volume that is in use. However, snapshots only /// capture data that has been written to your Amazon EBS volume at the time the snapshot /// command is issued; this might exclude any data that has been cached by any applications /// or the operating system. If you can pause any file systems on the volume long enough /// to take a snapshot, your snapshot should be complete. However, if you cannot pause /// all file writes to the volume, you should unmount the volume from within the instance, /// issue the snapshot command, and then remount the volume to ensure a consistent and /// complete snapshot. You may remount and use your volume while the snapshot status is /// pending. /// /// /// /// When you create a snapshot for an EBS volume that serves as a root device, we recommend /// that you stop the instance before taking the snapshot. /// /// /// /// Snapshots that are taken from encrypted volumes are automatically encrypted. Volumes /// that are created from encrypted snapshots are also automatically encrypted. Your encrypted /// volumes and any associated snapshots always remain protected. /// /// /// /// You can tag your snapshots during creation. For more information, see Tag /// your Amazon EC2 resources in the Amazon Elastic Compute Cloud User Guide. /// /// /// /// For more information, see Amazon /// Elastic Block Store and Amazon /// EBS encryption in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSnapshot service method, as returned by EC2. /// REST API Reference for CreateSnapshot Operation Task CreateSnapshotAsync(CreateSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateSnapshots ///

/// Creates crash-consistent snapshots of multiple EBS volumes and stores the data in /// S3. Volumes are chosen by specifying an instance. Any attached volumes will produce /// one snapshot each that is crash-consistent across the instance. /// /// /// /// You can include all of the volumes currently attached to the instance, or you can /// exclude the root volume or specific data (non-root) volumes from the multi-volume /// snapshot set. /// /// /// /// You can create multi-volume snapshots of instances in a Region and instances on an /// Outpost. If you create snapshots from an instance in a Region, the snapshots must /// be stored in the same Region as the instance. If you create snapshots from an instance /// on an Outpost, the snapshots can be stored on the same Outpost as the instance, or /// in the Region for that Outpost. /// ///

/// Container for the necessary parameters to execute the CreateSnapshots service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSnapshots service method, as returned by EC2. /// REST API Reference for CreateSnapshots Operation Task CreateSnapshotsAsync(CreateSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateSpotDatafeedSubscription ///

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

/// Container for the necessary parameters to execute the CreateSpotDatafeedSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSpotDatafeedSubscription service method, as returned by EC2. /// REST API Reference for CreateSpotDatafeedSubscription Operation Task CreateSpotDatafeedSubscriptionAsync(CreateSpotDatafeedSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateStoreImageTask ///

/// Stores an AMI as a single object in an Amazon S3 bucket. /// /// /// /// To use this API, you must have the required permissions. For more information, see /// Permissions /// for storing and restoring AMIs using Amazon S3 in the Amazon EC2 User Guide. /// /// /// /// For more information, see Store /// and restore an AMI using Amazon S3 in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the CreateStoreImageTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateStoreImageTask service method, as returned by EC2. /// REST API Reference for CreateStoreImageTask Operation Task CreateStoreImageTaskAsync(CreateStoreImageTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateSubnet ///

/// Creates a subnet in the specified VPC. For an IPv4 only subnet, specify an IPv4 CIDR /// block. If the VPC has an IPv6 CIDR block, you can create an IPv6 only subnet or a /// dual stack subnet instead. For an IPv6 only subnet, specify an IPv6 CIDR block. For /// a dual stack subnet, specify both an IPv4 CIDR block and an IPv6 CIDR block. /// /// /// /// A subnet CIDR block must not overlap the CIDR block of an existing subnet in the VPC. /// After you create a subnet, you can't change its CIDR block. /// /// /// /// The allowed size for an IPv4 subnet is between a /28 netmask (16 IP addresses) and /// a /16 netmask (65,536 IP addresses). Amazon Web Services reserves both the first four /// and the last IPv4 address in each subnet's CIDR block. They're not available for your /// use. /// /// /// /// If you've associated an IPv6 CIDR block with your VPC, you can associate an IPv6 CIDR /// block with a subnet when you create it. The allowed block size for an IPv6 subnet /// is a /64 netmask. /// /// /// /// If you add more than one subnet to a VPC, they're set up in a star topology with a /// logical router in the middle. /// /// /// /// When you stop an instance in a subnet, it retains its private IPv4 address. It's therefore /// possible to have a subnet with no running instances (they're all stopped), but no /// remaining IP addresses available. /// /// /// /// For more information, see Subnets /// in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the CreateSubnet service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSubnet service method, as returned by EC2. /// REST API Reference for CreateSubnet Operation Task CreateSubnetAsync(CreateSubnetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateSubnetCidrReservation ///

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

/// Container for the necessary parameters to execute the CreateSubnetCidrReservation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSubnetCidrReservation service method, as returned by EC2. /// REST API Reference for CreateSubnetCidrReservation Operation Task CreateSubnetCidrReservationAsync(CreateSubnetCidrReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTags ///

/// Adds or overwrites only the specified tags for the specified Amazon EC2 resource or /// resources. When you specify an existing tag key, the value is overwritten with the /// new value. Each resource can have a maximum of 50 tags. Each tag consists of a key /// and optional value. Tag keys must be unique per resource. /// /// /// /// For more information about tags, see Tag /// your Amazon EC2 resources in the Amazon Elastic Compute Cloud User Guide. /// For more information about creating IAM policies that control users' access to resources /// based on tags, see Supported /// resource-level permissions for Amazon EC2 API actions in the Amazon Elastic /// Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateTags service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTags service method, as returned by EC2. /// REST API Reference for CreateTags Operation Task CreateTagsAsync(CreateTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTrafficMirrorFilter ///

/// Creates a Traffic Mirror filter. /// /// /// /// A Traffic Mirror filter is a set of rules that defines the traffic to mirror. /// /// /// /// By default, no traffic is mirrored. To mirror traffic, use CreateTrafficMirrorFilterRule /// to add Traffic Mirror rules to the filter. The rules you add define what traffic gets /// mirrored. You can also use ModifyTrafficMirrorFilterNetworkServices /// to mirror supported network services. /// ///

/// Container for the necessary parameters to execute the CreateTrafficMirrorFilter service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTrafficMirrorFilter service method, as returned by EC2. /// REST API Reference for CreateTrafficMirrorFilter Operation Task CreateTrafficMirrorFilterAsync(CreateTrafficMirrorFilterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTrafficMirrorFilterRule ///

/// Creates a Traffic Mirror filter rule. /// /// /// /// A Traffic Mirror rule defines the Traffic Mirror source traffic to mirror. /// /// /// /// You need the Traffic Mirror filter ID when you create the rule. /// ///

/// Container for the necessary parameters to execute the CreateTrafficMirrorFilterRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTrafficMirrorFilterRule service method, as returned by EC2. /// REST API Reference for CreateTrafficMirrorFilterRule Operation Task CreateTrafficMirrorFilterRuleAsync(CreateTrafficMirrorFilterRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTrafficMirrorSession ///

/// Creates a Traffic Mirror session. /// /// /// /// A Traffic Mirror session actively copies packets from a Traffic Mirror source to a /// Traffic Mirror target. Create a filter, and then assign it to the session to define /// a subset of the traffic to mirror, for example all TCP traffic. /// /// /// /// The Traffic Mirror source and the Traffic Mirror target (monitoring appliances) can /// be in the same VPC, or in a different VPC connected via VPC peering or a transit gateway. /// /// /// /// /// By default, no traffic is mirrored. Use CreateTrafficMirrorFilter /// to create filter rules that specify the traffic to mirror. /// ///

/// Container for the necessary parameters to execute the CreateTrafficMirrorSession service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTrafficMirrorSession service method, as returned by EC2. /// REST API Reference for CreateTrafficMirrorSession Operation Task CreateTrafficMirrorSessionAsync(CreateTrafficMirrorSessionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTrafficMirrorTarget ///

/// Creates a target for your Traffic Mirror session. /// /// /// /// A Traffic Mirror target is the destination for mirrored traffic. The Traffic Mirror /// source and the Traffic Mirror target (monitoring appliances) can be in the same VPC, /// or in different VPCs connected via VPC peering or a transit gateway. /// /// /// /// A Traffic Mirror target can be a network interface, a Network Load Balancer, or a /// Gateway Load Balancer endpoint. /// /// /// /// To use the target in a Traffic Mirror session, use CreateTrafficMirrorSession. /// ///

/// Container for the necessary parameters to execute the CreateTrafficMirrorTarget service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTrafficMirrorTarget service method, as returned by EC2. /// REST API Reference for CreateTrafficMirrorTarget Operation Task CreateTrafficMirrorTargetAsync(CreateTrafficMirrorTargetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGateway ///

/// Creates a transit gateway. /// /// /// /// You can use a transit gateway to interconnect your virtual private clouds (VPC) and /// on-premises networks. After the transit gateway enters the available /// state, you can attach your VPCs and VPN connections to the transit gateway. /// /// /// /// To attach your VPCs, use CreateTransitGatewayVpcAttachment. /// /// /// /// To attach a VPN connection, use CreateCustomerGateway to create a customer /// gateway and specify the ID of the customer gateway and the ID of the transit gateway /// in a call to CreateVpnConnection. /// /// /// /// When you create a transit gateway, we create a default transit gateway route table /// and use it as the default association route table and the default propagation route /// table. You can use CreateTransitGatewayRouteTable to create additional transit /// gateway route tables. If you disable automatic route propagation, we do not create /// a default transit gateway route table. You can use EnableTransitGatewayRouteTablePropagation /// to propagate routes from a resource attachment to a transit gateway route table. If /// you disable automatic associations, you can use AssociateTransitGatewayRouteTable /// to associate a resource attachment with a transit gateway route table. /// ///

/// Container for the necessary parameters to execute the CreateTransitGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGateway service method, as returned by EC2. /// REST API Reference for CreateTransitGateway Operation Task CreateTransitGatewayAsync(CreateTransitGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayConnect ///

/// Creates a Connect attachment from a specified transit gateway attachment. A Connect /// attachment is a GRE-based tunnel attachment that you can use to establish a connection /// between a transit gateway and an appliance. /// /// /// /// A Connect attachment uses an existing VPC or Amazon Web Services Direct Connect attachment /// as the underlying transport mechanism. /// ///

/// Container for the necessary parameters to execute the CreateTransitGatewayConnect service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayConnect service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayConnect Operation Task CreateTransitGatewayConnectAsync(CreateTransitGatewayConnectRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayConnectPeer ///

/// Creates a Connect peer for a specified transit gateway Connect attachment between /// a transit gateway and an appliance. /// /// /// /// The peer address and transit gateway address must be the same IP address family (IPv4 /// or IPv6). /// /// /// /// For more information, see Connect /// peers in the Transit Gateways Guide. /// ///

/// Container for the necessary parameters to execute the CreateTransitGatewayConnectPeer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayConnectPeer service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayConnectPeer Operation Task CreateTransitGatewayConnectPeerAsync(CreateTransitGatewayConnectPeerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayMulticastDomain ///

/// Creates a multicast domain using the specified transit gateway. /// /// /// /// The transit gateway must be in the available state before you create a domain. Use /// DescribeTransitGateways /// to see the state of transit gateway. /// ///

/// Container for the necessary parameters to execute the CreateTransitGatewayMulticastDomain service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayMulticastDomain service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayMulticastDomain Operation Task CreateTransitGatewayMulticastDomainAsync(CreateTransitGatewayMulticastDomainRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayPeeringAttachment ///

/// Requests a transit gateway peering attachment between the specified transit gateway /// (requester) and a peer transit gateway (accepter). The peer transit gateway can be /// in your account or a different Amazon Web Services account. /// /// /// /// After you create the peering attachment, the owner of the accepter transit gateway /// must accept the attachment request. /// ///

/// Container for the necessary parameters to execute the CreateTransitGatewayPeeringAttachment service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayPeeringAttachment service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayPeeringAttachment Operation Task CreateTransitGatewayPeeringAttachmentAsync(CreateTransitGatewayPeeringAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayPolicyTable ///

/// Creates a transit gateway policy table. ///

/// Container for the necessary parameters to execute the CreateTransitGatewayPolicyTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayPolicyTable service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayPolicyTable Operation Task CreateTransitGatewayPolicyTableAsync(CreateTransitGatewayPolicyTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayPrefixListReference ///

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

/// Container for the necessary parameters to execute the CreateTransitGatewayPrefixListReference service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayPrefixListReference service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayPrefixListReference Operation Task CreateTransitGatewayPrefixListReferenceAsync(CreateTransitGatewayPrefixListReferenceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayRoute ///

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

/// Container for the necessary parameters to execute the CreateTransitGatewayRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayRoute service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayRoute Operation Task CreateTransitGatewayRouteAsync(CreateTransitGatewayRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayRouteTable ///

/// Creates a route table for the specified transit gateway. ///

/// Container for the necessary parameters to execute the CreateTransitGatewayRouteTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayRouteTable service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayRouteTable Operation Task CreateTransitGatewayRouteTableAsync(CreateTransitGatewayRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayRouteTableAnnouncement ///

/// Advertises a new transit gateway route table. ///

/// Container for the necessary parameters to execute the CreateTransitGatewayRouteTableAnnouncement service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayRouteTableAnnouncement service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayRouteTableAnnouncement Operation Task CreateTransitGatewayRouteTableAnnouncementAsync(CreateTransitGatewayRouteTableAnnouncementRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateTransitGatewayVpcAttachment ///

/// Attaches the specified VPC to the specified transit gateway. /// /// /// /// If you attach a VPC with a CIDR range that overlaps the CIDR range of a VPC that is /// already attached, the new VPC CIDR range is not propagated to the default propagation /// route table. /// /// /// /// To send VPC traffic to an attached transit gateway, add a route to the VPC route table /// using CreateRoute. /// ///

/// Container for the necessary parameters to execute the CreateTransitGatewayVpcAttachment service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTransitGatewayVpcAttachment service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayVpcAttachment Operation Task CreateTransitGatewayVpcAttachmentAsync(CreateTransitGatewayVpcAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVerifiedAccessEndpoint ///

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

/// Container for the necessary parameters to execute the CreateVerifiedAccessEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVerifiedAccessEndpoint service method, as returned by EC2. /// REST API Reference for CreateVerifiedAccessEndpoint Operation Task CreateVerifiedAccessEndpointAsync(CreateVerifiedAccessEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVerifiedAccessGroup ///

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

/// Container for the necessary parameters to execute the CreateVerifiedAccessGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVerifiedAccessGroup service method, as returned by EC2. /// REST API Reference for CreateVerifiedAccessGroup Operation Task CreateVerifiedAccessGroupAsync(CreateVerifiedAccessGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVerifiedAccessInstance ///

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

/// Container for the necessary parameters to execute the CreateVerifiedAccessInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVerifiedAccessInstance service method, as returned by EC2. /// REST API Reference for CreateVerifiedAccessInstance Operation Task CreateVerifiedAccessInstanceAsync(CreateVerifiedAccessInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVerifiedAccessTrustProvider ///

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

/// Container for the necessary parameters to execute the CreateVerifiedAccessTrustProvider service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVerifiedAccessTrustProvider service method, as returned by EC2. /// REST API Reference for CreateVerifiedAccessTrustProvider Operation Task CreateVerifiedAccessTrustProviderAsync(CreateVerifiedAccessTrustProviderRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVolume ///

/// Creates an EBS volume that can be attached to an instance in the same Availability /// Zone. /// /// /// /// You can create a new empty volume or restore a volume from an EBS snapshot. Any Amazon /// Web Services Marketplace product codes from the snapshot are propagated to the volume. /// /// /// /// You can create encrypted volumes. Encrypted volumes must be attached to instances /// that support Amazon EBS encryption. Volumes that are created from encrypted snapshots /// are also automatically encrypted. For more information, see Amazon /// EBS encryption in the Amazon Elastic Compute Cloud User Guide. /// /// /// /// You can tag your volumes during creation. For more information, see Tag /// your Amazon EC2 resources in the Amazon Elastic Compute Cloud User Guide. /// /// /// /// For more information, see Create /// an Amazon EBS volume in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the CreateVolume service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVolume service method, as returned by EC2. /// REST API Reference for CreateVolume Operation Task CreateVolumeAsync(CreateVolumeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVpc ///

/// Creates a VPC with the specified CIDR blocks. For more information, see IP /// addressing for your VPCs and subnets in the Amazon VPC User Guide. /// /// /// /// You can optionally request an IPv6 CIDR block for the VPC. You can request an Amazon-provided /// IPv6 CIDR block from Amazon's pool of IPv6 addresses, or an IPv6 CIDR block from an /// IPv6 address pool that you provisioned through bring your own IP addresses (BYOIP). /// /// /// /// By default, each instance that you launch in the VPC has the default DHCP options, /// which include only a default DNS server that we provide (AmazonProvidedDNS). For more /// information, see DHCP /// option sets in the Amazon VPC User Guide. /// /// /// /// You can specify the instance tenancy value for the VPC when you create it. You can't /// change this value for the VPC after you create it. For more information, see Dedicated /// Instances in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the CreateVpc service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVpc service method, as returned by EC2. /// REST API Reference for CreateVpc Operation Task CreateVpcAsync(CreateVpcRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVpcEndpoint ///

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

/// Container for the necessary parameters to execute the CreateVpcEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVpcEndpoint service method, as returned by EC2. /// REST API Reference for CreateVpcEndpoint Operation Task CreateVpcEndpointAsync(CreateVpcEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVpcEndpointConnectionNotification ///

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

/// Container for the necessary parameters to execute the CreateVpcEndpointConnectionNotification service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVpcEndpointConnectionNotification service method, as returned by EC2. /// REST API Reference for CreateVpcEndpointConnectionNotification Operation Task CreateVpcEndpointConnectionNotificationAsync(CreateVpcEndpointConnectionNotificationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVpcEndpointServiceConfiguration ///

/// Creates a VPC endpoint service to which service consumers (Amazon Web Services accounts, /// users, and IAM roles) can connect. /// /// /// /// Before you create an endpoint service, you must create one of the following for your /// service: /// ///

/// /// A Network /// Load Balancer. Service consumers connect to your service using an interface endpoint. /// ///
/// /// A Gateway /// Load Balancer. Service consumers connect to your service using a Gateway Load /// Balancer endpoint. /// ///

/// /// If you set the private DNS name, you must prove that you own the private DNS domain /// name. /// /// /// /// For more information, see the Amazon /// Web Services PrivateLink Guide. /// ///

/// Container for the necessary parameters to execute the CreateVpcEndpointServiceConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVpcEndpointServiceConfiguration service method, as returned by EC2. /// REST API Reference for CreateVpcEndpointServiceConfiguration Operation Task CreateVpcEndpointServiceConfigurationAsync(CreateVpcEndpointServiceConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVpcPeeringConnection ///

/// Requests a VPC peering connection between two VPCs: a requester VPC that you own and /// an accepter VPC with which to create the connection. The accepter VPC can belong to /// another Amazon Web Services account and can be in a different Region to the requester /// VPC. The requester VPC and accepter VPC cannot have overlapping CIDR blocks. /// /// /// /// Limitations and rules apply to a VPC peering connection. For more information, see /// the limitations /// section in the VPC Peering Guide. /// /// /// /// The owner of the accepter VPC must accept the peering request to activate the peering /// connection. The VPC peering connection request expires after 7 days, after which it /// cannot be accepted or rejected. /// /// /// /// If you create a VPC peering connection request between VPCs with overlapping CIDR /// blocks, the VPC peering connection has a status of failed. /// ///

/// Container for the necessary parameters to execute the CreateVpcPeeringConnection service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVpcPeeringConnection service method, as returned by EC2. /// REST API Reference for CreateVpcPeeringConnection Operation Task CreateVpcPeeringConnectionAsync(CreateVpcPeeringConnectionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVpnConnection ///

/// Creates a VPN connection between an existing virtual private gateway or transit gateway /// and a customer gateway. The supported connection type is ipsec.1. /// /// /// /// The response includes information that you need to give to your network administrator /// to configure your customer gateway. /// /// /// /// We strongly recommend that you use HTTPS when calling this operation because the response /// contains sensitive cryptographic information for configuring your customer gateway /// device. /// /// /// /// If you decide to shut down your VPN connection for any reason and later create a new /// VPN connection, you must reconfigure your customer gateway with the new information /// returned from this call. /// /// /// /// This is an idempotent operation. If you perform the operation more than once, Amazon /// EC2 doesn't return an error. /// /// /// /// For more information, see Amazon /// Web Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN User /// Guide. /// ///

/// Container for the necessary parameters to execute the CreateVpnConnection service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVpnConnection service method, as returned by EC2. /// REST API Reference for CreateVpnConnection Operation Task CreateVpnConnectionAsync(CreateVpnConnectionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVpnConnectionRoute ///

/// Creates a static route associated with a VPN connection between an existing virtual /// private gateway and a VPN customer gateway. The static route allows traffic to be /// routed from the virtual private gateway to the VPN customer gateway. /// /// /// /// For more information, see Amazon /// Web Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN User /// Guide. /// ///

/// Container for the necessary parameters to execute the CreateVpnConnectionRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVpnConnectionRoute service method, as returned by EC2. /// REST API Reference for CreateVpnConnectionRoute Operation Task CreateVpnConnectionRouteAsync(CreateVpnConnectionRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region CreateVpnGateway ///

/// Creates a virtual private gateway. A virtual private gateway is the endpoint on the /// VPC side of your VPN connection. You can create a virtual private gateway before creating /// the VPC itself. /// /// /// /// For more information, see Amazon /// Web Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN User /// Guide. /// ///

/// Container for the necessary parameters to execute the CreateVpnGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateVpnGateway service method, as returned by EC2. /// REST API Reference for CreateVpnGateway Operation Task CreateVpnGatewayAsync(CreateVpnGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteCarrierGateway ///

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

/// Container for the necessary parameters to execute the DeleteCarrierGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCarrierGateway service method, as returned by EC2. /// REST API Reference for DeleteCarrierGateway Operation Task DeleteCarrierGatewayAsync(DeleteCarrierGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteClientVpnEndpoint ///

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

/// Container for the necessary parameters to execute the DeleteClientVpnEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteClientVpnEndpoint service method, as returned by EC2. /// REST API Reference for DeleteClientVpnEndpoint Operation Task DeleteClientVpnEndpointAsync(DeleteClientVpnEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteClientVpnRoute ///

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

/// Container for the necessary parameters to execute the DeleteClientVpnRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteClientVpnRoute service method, as returned by EC2. /// REST API Reference for DeleteClientVpnRoute Operation Task DeleteClientVpnRouteAsync(DeleteClientVpnRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteCoipCidr ///

/// Deletes a range of customer-owned IP addresses. ///

/// Container for the necessary parameters to execute the DeleteCoipCidr service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCoipCidr service method, as returned by EC2. /// REST API Reference for DeleteCoipCidr Operation Task DeleteCoipCidrAsync(DeleteCoipCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteCoipPool ///

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

/// Container for the necessary parameters to execute the DeleteCoipPool service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCoipPool service method, as returned by EC2. /// REST API Reference for DeleteCoipPool Operation Task DeleteCoipPoolAsync(DeleteCoipPoolRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteCustomerGateway ///

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

/// Container for the necessary parameters to execute the DeleteCustomerGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCustomerGateway service method, as returned by EC2. /// REST API Reference for DeleteCustomerGateway Operation Task DeleteCustomerGatewayAsync(DeleteCustomerGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteDhcpOptions ///

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

/// Container for the necessary parameters to execute the DeleteDhcpOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDhcpOptions service method, as returned by EC2. /// REST API Reference for DeleteDhcpOptions Operation Task DeleteDhcpOptionsAsync(DeleteDhcpOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteEgressOnlyInternetGateway ///

/// Deletes an egress-only internet gateway. ///

/// Container for the necessary parameters to execute the DeleteEgressOnlyInternetGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteEgressOnlyInternetGateway service method, as returned by EC2. /// REST API Reference for DeleteEgressOnlyInternetGateway Operation Task DeleteEgressOnlyInternetGatewayAsync(DeleteEgressOnlyInternetGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteFleets ///

/// Deletes the specified EC2 Fleets. /// /// /// /// After you delete an EC2 Fleet, it launches no new instances. /// /// /// /// You must also specify whether a deleted EC2 Fleet should terminate its instances. /// If you choose to terminate the instances, the EC2 Fleet enters the deleted_terminating /// state. Otherwise, the EC2 Fleet enters the deleted_running state, and /// the instances continue to run until they are interrupted or you terminate them manually. /// /// /// /// For instant fleets, EC2 Fleet must terminate the instances when the fleet /// is deleted. A deleted instant fleet with running instances is not supported. /// ///

Restrictions /// ///

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

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

/// Container for the necessary parameters to execute the DeleteFleets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteFleets service method, as returned by EC2. /// REST API Reference for DeleteFleets Operation Task DeleteFleetsAsync(DeleteFleetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteFlowLogs ///

/// Deletes one or more flow logs. ///

/// Container for the necessary parameters to execute the DeleteFlowLogs service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteFlowLogs service method, as returned by EC2. /// REST API Reference for DeleteFlowLogs Operation Task DeleteFlowLogsAsync(DeleteFlowLogsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteFpgaImage ///

/// Deletes the specified Amazon FPGA Image (AFI). ///

/// Container for the necessary parameters to execute the DeleteFpgaImage service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteFpgaImage service method, as returned by EC2. /// REST API Reference for DeleteFpgaImage Operation Task DeleteFpgaImageAsync(DeleteFpgaImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteInstanceConnectEndpoint ///

/// Deletes the specified EC2 Instance Connect Endpoint. ///

/// Container for the necessary parameters to execute the DeleteInstanceConnectEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteInstanceConnectEndpoint service method, as returned by EC2. /// REST API Reference for DeleteInstanceConnectEndpoint Operation Task DeleteInstanceConnectEndpointAsync(DeleteInstanceConnectEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteInstanceEventWindow ///

/// Deletes the specified event window. /// /// /// /// For more information, see Define /// event windows for scheduled events in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteInstanceEventWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteInstanceEventWindow service method, as returned by EC2. /// REST API Reference for DeleteInstanceEventWindow Operation Task DeleteInstanceEventWindowAsync(DeleteInstanceEventWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteInternetGateway ///

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

/// Container for the necessary parameters to execute the DeleteInternetGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteInternetGateway service method, as returned by EC2. /// REST API Reference for DeleteInternetGateway Operation Task DeleteInternetGatewayAsync(DeleteInternetGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteIpam ///

/// Delete an IPAM. Deleting an IPAM removes all monitored data associated with the IPAM /// including the historical data for CIDRs. /// /// /// /// For more information, see Delete /// an IPAM in the Amazon VPC IPAM User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteIpam service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteIpam service method, as returned by EC2. /// REST API Reference for DeleteIpam Operation Task DeleteIpamAsync(DeleteIpamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteIpamPool ///

/// Delete an IPAM pool. /// /// /// /// You cannot delete an IPAM pool if there are allocations in it or CIDRs provisioned /// to it. To release allocations, see ReleaseIpamPoolAllocation. /// To deprovision pool CIDRs, see DeprovisionIpamPoolCidr. /// /// /// /// For more information, see Delete /// a pool in the Amazon VPC IPAM User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteIpamPool service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteIpamPool service method, as returned by EC2. /// REST API Reference for DeleteIpamPool Operation Task DeleteIpamPoolAsync(DeleteIpamPoolRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteIpamResourceDiscovery ///

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

/// Container for the necessary parameters to execute the DeleteIpamResourceDiscovery service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteIpamResourceDiscovery service method, as returned by EC2. /// REST API Reference for DeleteIpamResourceDiscovery Operation Task DeleteIpamResourceDiscoveryAsync(DeleteIpamResourceDiscoveryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteIpamScope ///

/// Delete the scope for an IPAM. You cannot delete the default scopes. /// /// /// /// For more information, see Delete /// a scope in the Amazon VPC IPAM User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteIpamScope service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteIpamScope service method, as returned by EC2. /// REST API Reference for DeleteIpamScope Operation Task DeleteIpamScopeAsync(DeleteIpamScopeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteKeyPair ///

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

/// Container for the necessary parameters to execute the DeleteKeyPair service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteKeyPair service method, as returned by EC2. /// REST API Reference for DeleteKeyPair Operation Task DeleteKeyPairAsync(DeleteKeyPairRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLaunchTemplate ///

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

/// Container for the necessary parameters to execute the DeleteLaunchTemplate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteLaunchTemplate service method, as returned by EC2. /// REST API Reference for DeleteLaunchTemplate Operation Task DeleteLaunchTemplateAsync(DeleteLaunchTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLaunchTemplateVersions ///

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

/// Container for the necessary parameters to execute the DeleteLaunchTemplateVersions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteLaunchTemplateVersions service method, as returned by EC2. /// REST API Reference for DeleteLaunchTemplateVersions Operation Task DeleteLaunchTemplateVersionsAsync(DeleteLaunchTemplateVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLocalGatewayRoute ///

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

/// Container for the necessary parameters to execute the DeleteLocalGatewayRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteLocalGatewayRoute service method, as returned by EC2. /// REST API Reference for DeleteLocalGatewayRoute Operation Task DeleteLocalGatewayRouteAsync(DeleteLocalGatewayRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLocalGatewayRouteTable ///

/// Deletes a local gateway route table. ///

/// Container for the necessary parameters to execute the DeleteLocalGatewayRouteTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteLocalGatewayRouteTable service method, as returned by EC2. /// REST API Reference for DeleteLocalGatewayRouteTable Operation Task DeleteLocalGatewayRouteTableAsync(DeleteLocalGatewayRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation ///

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

/// Container for the necessary parameters to execute the DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation service method, as returned by EC2. /// REST API Reference for DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation Operation Task DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationAsync(DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteLocalGatewayRouteTableVpcAssociation ///

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

/// Container for the necessary parameters to execute the DeleteLocalGatewayRouteTableVpcAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteLocalGatewayRouteTableVpcAssociation service method, as returned by EC2. /// REST API Reference for DeleteLocalGatewayRouteTableVpcAssociation Operation Task DeleteLocalGatewayRouteTableVpcAssociationAsync(DeleteLocalGatewayRouteTableVpcAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteManagedPrefixList ///

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

/// Container for the necessary parameters to execute the DeleteManagedPrefixList service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteManagedPrefixList service method, as returned by EC2. /// REST API Reference for DeleteManagedPrefixList Operation Task DeleteManagedPrefixListAsync(DeleteManagedPrefixListRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNatGateway ///

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

/// Container for the necessary parameters to execute the DeleteNatGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteNatGateway service method, as returned by EC2. /// REST API Reference for DeleteNatGateway Operation Task DeleteNatGatewayAsync(DeleteNatGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNetworkAcl ///

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

/// Container for the necessary parameters to execute the DeleteNetworkAcl service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteNetworkAcl service method, as returned by EC2. /// REST API Reference for DeleteNetworkAcl Operation Task DeleteNetworkAclAsync(DeleteNetworkAclRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNetworkAclEntry ///

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

/// Container for the necessary parameters to execute the DeleteNetworkAclEntry service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteNetworkAclEntry service method, as returned by EC2. /// REST API Reference for DeleteNetworkAclEntry Operation Task DeleteNetworkAclEntryAsync(DeleteNetworkAclEntryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNetworkInsightsAccessScope ///

/// Deletes the specified Network Access Scope. ///

/// Container for the necessary parameters to execute the DeleteNetworkInsightsAccessScope service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteNetworkInsightsAccessScope service method, as returned by EC2. /// REST API Reference for DeleteNetworkInsightsAccessScope Operation Task DeleteNetworkInsightsAccessScopeAsync(DeleteNetworkInsightsAccessScopeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNetworkInsightsAccessScopeAnalysis ///

/// Deletes the specified Network Access Scope analysis. ///

/// Container for the necessary parameters to execute the DeleteNetworkInsightsAccessScopeAnalysis service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteNetworkInsightsAccessScopeAnalysis service method, as returned by EC2. /// REST API Reference for DeleteNetworkInsightsAccessScopeAnalysis Operation Task DeleteNetworkInsightsAccessScopeAnalysisAsync(DeleteNetworkInsightsAccessScopeAnalysisRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNetworkInsightsAnalysis ///

/// Deletes the specified network insights analysis. ///

/// Container for the necessary parameters to execute the DeleteNetworkInsightsAnalysis service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteNetworkInsightsAnalysis service method, as returned by EC2. /// REST API Reference for DeleteNetworkInsightsAnalysis Operation Task DeleteNetworkInsightsAnalysisAsync(DeleteNetworkInsightsAnalysisRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNetworkInsightsPath ///

/// Deletes the specified path. ///

/// Container for the necessary parameters to execute the DeleteNetworkInsightsPath service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteNetworkInsightsPath service method, as returned by EC2. /// REST API Reference for DeleteNetworkInsightsPath Operation Task DeleteNetworkInsightsPathAsync(DeleteNetworkInsightsPathRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNetworkInterface ///

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

/// Container for the necessary parameters to execute the DeleteNetworkInterface service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteNetworkInterface service method, as returned by EC2. /// REST API Reference for DeleteNetworkInterface Operation Task DeleteNetworkInterfaceAsync(DeleteNetworkInterfaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteNetworkInterfacePermission ///

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

/// Container for the necessary parameters to execute the DeleteNetworkInterfacePermission service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteNetworkInterfacePermission service method, as returned by EC2. /// REST API Reference for DeleteNetworkInterfacePermission Operation Task DeleteNetworkInterfacePermissionAsync(DeleteNetworkInterfacePermissionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeletePlacementGroup ///

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

/// Container for the necessary parameters to execute the DeletePlacementGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePlacementGroup service method, as returned by EC2. /// REST API Reference for DeletePlacementGroup Operation Task DeletePlacementGroupAsync(DeletePlacementGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeletePublicIpv4Pool ///

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

/// Container for the necessary parameters to execute the DeletePublicIpv4Pool service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePublicIpv4Pool service method, as returned by EC2. /// REST API Reference for DeletePublicIpv4Pool Operation Task DeletePublicIpv4PoolAsync(DeletePublicIpv4PoolRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteQueuedReservedInstances ///

/// Deletes the queued purchases for the specified Reserved Instances. ///

/// Container for the necessary parameters to execute the DeleteQueuedReservedInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteQueuedReservedInstances service method, as returned by EC2. /// REST API Reference for DeleteQueuedReservedInstances Operation Task DeleteQueuedReservedInstancesAsync(DeleteQueuedReservedInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteRoute ///

/// Deletes the specified route from the specified route table. ///

/// Container for the necessary parameters to execute the DeleteRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteRoute service method, as returned by EC2. /// REST API Reference for DeleteRoute Operation Task DeleteRouteAsync(DeleteRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteRouteTable ///

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

/// Container for the necessary parameters to execute the DeleteRouteTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteRouteTable service method, as returned by EC2. /// REST API Reference for DeleteRouteTable Operation Task DeleteRouteTableAsync(DeleteRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteSecurityGroup ///

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

/// Container for the necessary parameters to execute the DeleteSecurityGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSecurityGroup service method, as returned by EC2. /// REST API Reference for DeleteSecurityGroup Operation Task DeleteSecurityGroupAsync(DeleteSecurityGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteSnapshot ///

/// Deletes the specified snapshot. /// /// /// /// When you make periodic snapshots of a volume, the snapshots are incremental, and only /// the blocks on the device that have changed since your last snapshot are saved in the /// new snapshot. When you delete a snapshot, only the data not needed for any other snapshot /// is removed. So regardless of which prior snapshots have been deleted, all active snapshots /// will have access to all the information needed to restore the volume. /// /// /// /// You cannot delete a snapshot of the root device of an EBS volume used by a registered /// AMI. You must first de-register the AMI before you can delete the snapshot. /// /// /// /// For more information, see Delete /// an Amazon EBS snapshot in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSnapshot service method, as returned by EC2. /// REST API Reference for DeleteSnapshot Operation Task DeleteSnapshotAsync(DeleteSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteSpotDatafeedSubscription ///

/// Deletes the data feed for Spot Instances. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSpotDatafeedSubscription service method, as returned by EC2. /// REST API Reference for DeleteSpotDatafeedSubscription Operation Task DeleteSpotDatafeedSubscriptionAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Deletes the data feed for Spot Instances. ///

/// Container for the necessary parameters to execute the DeleteSpotDatafeedSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSpotDatafeedSubscription service method, as returned by EC2. /// REST API Reference for DeleteSpotDatafeedSubscription Operation Task DeleteSpotDatafeedSubscriptionAsync(DeleteSpotDatafeedSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteSubnet ///

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

/// Container for the necessary parameters to execute the DeleteSubnet service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSubnet service method, as returned by EC2. /// REST API Reference for DeleteSubnet Operation Task DeleteSubnetAsync(DeleteSubnetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteSubnetCidrReservation ///

/// Deletes a subnet CIDR reservation. ///

/// Container for the necessary parameters to execute the DeleteSubnetCidrReservation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSubnetCidrReservation service method, as returned by EC2. /// REST API Reference for DeleteSubnetCidrReservation Operation Task DeleteSubnetCidrReservationAsync(DeleteSubnetCidrReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTags ///

/// Deletes the specified set of tags from the specified set of resources. /// /// /// /// To list the current tags, use DescribeTags. For more information about tags, /// see Tag /// your Amazon EC2 resources in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteTags service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTags service method, as returned by EC2. /// REST API Reference for DeleteTags Operation Task DeleteTagsAsync(DeleteTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTrafficMirrorFilter ///

/// Deletes the specified Traffic Mirror filter. /// /// /// /// You cannot delete a Traffic Mirror filter that is in use by a Traffic Mirror session. /// ///

/// Container for the necessary parameters to execute the DeleteTrafficMirrorFilter service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTrafficMirrorFilter service method, as returned by EC2. /// REST API Reference for DeleteTrafficMirrorFilter Operation Task DeleteTrafficMirrorFilterAsync(DeleteTrafficMirrorFilterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTrafficMirrorFilterRule ///

/// Deletes the specified Traffic Mirror rule. ///

/// Container for the necessary parameters to execute the DeleteTrafficMirrorFilterRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTrafficMirrorFilterRule service method, as returned by EC2. /// REST API Reference for DeleteTrafficMirrorFilterRule Operation Task DeleteTrafficMirrorFilterRuleAsync(DeleteTrafficMirrorFilterRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTrafficMirrorSession ///

/// Deletes the specified Traffic Mirror session. ///

/// Container for the necessary parameters to execute the DeleteTrafficMirrorSession service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTrafficMirrorSession service method, as returned by EC2. /// REST API Reference for DeleteTrafficMirrorSession Operation Task DeleteTrafficMirrorSessionAsync(DeleteTrafficMirrorSessionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTrafficMirrorTarget ///

/// Deletes the specified Traffic Mirror target. /// /// /// /// You cannot delete a Traffic Mirror target that is in use by a Traffic Mirror session. /// ///

/// Container for the necessary parameters to execute the DeleteTrafficMirrorTarget service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTrafficMirrorTarget service method, as returned by EC2. /// REST API Reference for DeleteTrafficMirrorTarget Operation Task DeleteTrafficMirrorTargetAsync(DeleteTrafficMirrorTargetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGateway ///

/// Deletes the specified transit gateway. ///

/// Container for the necessary parameters to execute the DeleteTransitGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGateway service method, as returned by EC2. /// REST API Reference for DeleteTransitGateway Operation Task DeleteTransitGatewayAsync(DeleteTransitGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayConnect ///

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

/// Container for the necessary parameters to execute the DeleteTransitGatewayConnect service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayConnect service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayConnect Operation Task DeleteTransitGatewayConnectAsync(DeleteTransitGatewayConnectRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayConnectPeer ///

/// Deletes the specified Connect peer. ///

/// Container for the necessary parameters to execute the DeleteTransitGatewayConnectPeer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayConnectPeer service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayConnectPeer Operation Task DeleteTransitGatewayConnectPeerAsync(DeleteTransitGatewayConnectPeerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayMulticastDomain ///

/// Deletes the specified transit gateway multicast domain. ///

/// Container for the necessary parameters to execute the DeleteTransitGatewayMulticastDomain service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayMulticastDomain service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayMulticastDomain Operation Task DeleteTransitGatewayMulticastDomainAsync(DeleteTransitGatewayMulticastDomainRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayPeeringAttachment ///

/// Deletes a transit gateway peering attachment. ///

/// Container for the necessary parameters to execute the DeleteTransitGatewayPeeringAttachment service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayPeeringAttachment service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayPeeringAttachment Operation Task DeleteTransitGatewayPeeringAttachmentAsync(DeleteTransitGatewayPeeringAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayPolicyTable ///

/// Deletes the specified transit gateway policy table. ///

/// Container for the necessary parameters to execute the DeleteTransitGatewayPolicyTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayPolicyTable service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayPolicyTable Operation Task DeleteTransitGatewayPolicyTableAsync(DeleteTransitGatewayPolicyTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayPrefixListReference ///

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

/// Container for the necessary parameters to execute the DeleteTransitGatewayPrefixListReference service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayPrefixListReference service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayPrefixListReference Operation Task DeleteTransitGatewayPrefixListReferenceAsync(DeleteTransitGatewayPrefixListReferenceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayRoute ///

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

/// Container for the necessary parameters to execute the DeleteTransitGatewayRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayRoute service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayRoute Operation Task DeleteTransitGatewayRouteAsync(DeleteTransitGatewayRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayRouteTable ///

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

/// Container for the necessary parameters to execute the DeleteTransitGatewayRouteTable service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayRouteTable service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayRouteTable Operation Task DeleteTransitGatewayRouteTableAsync(DeleteTransitGatewayRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayRouteTableAnnouncement ///

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

/// Container for the necessary parameters to execute the DeleteTransitGatewayRouteTableAnnouncement service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayRouteTableAnnouncement service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayRouteTableAnnouncement Operation Task DeleteTransitGatewayRouteTableAnnouncementAsync(DeleteTransitGatewayRouteTableAnnouncementRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteTransitGatewayVpcAttachment ///

/// Deletes the specified VPC attachment. ///

/// Container for the necessary parameters to execute the DeleteTransitGatewayVpcAttachment service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTransitGatewayVpcAttachment service method, as returned by EC2. /// REST API Reference for DeleteTransitGatewayVpcAttachment Operation Task DeleteTransitGatewayVpcAttachmentAsync(DeleteTransitGatewayVpcAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVerifiedAccessEndpoint ///

/// Delete an Amazon Web Services Verified Access endpoint. ///

/// Container for the necessary parameters to execute the DeleteVerifiedAccessEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVerifiedAccessEndpoint service method, as returned by EC2. /// REST API Reference for DeleteVerifiedAccessEndpoint Operation Task DeleteVerifiedAccessEndpointAsync(DeleteVerifiedAccessEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVerifiedAccessGroup ///

/// Delete an Amazon Web Services Verified Access group. ///

/// Container for the necessary parameters to execute the DeleteVerifiedAccessGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVerifiedAccessGroup service method, as returned by EC2. /// REST API Reference for DeleteVerifiedAccessGroup Operation Task DeleteVerifiedAccessGroupAsync(DeleteVerifiedAccessGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVerifiedAccessInstance ///

/// Delete an Amazon Web Services Verified Access instance. ///

/// Container for the necessary parameters to execute the DeleteVerifiedAccessInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVerifiedAccessInstance service method, as returned by EC2. /// REST API Reference for DeleteVerifiedAccessInstance Operation Task DeleteVerifiedAccessInstanceAsync(DeleteVerifiedAccessInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVerifiedAccessTrustProvider ///

/// Delete an Amazon Web Services Verified Access trust provider. ///

/// Container for the necessary parameters to execute the DeleteVerifiedAccessTrustProvider service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVerifiedAccessTrustProvider service method, as returned by EC2. /// REST API Reference for DeleteVerifiedAccessTrustProvider Operation Task DeleteVerifiedAccessTrustProviderAsync(DeleteVerifiedAccessTrustProviderRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVolume ///

/// Deletes the specified EBS volume. The volume must be in the available /// state (not attached to an instance). /// /// /// /// The volume can remain in the deleting state for several minutes. /// /// /// /// For more information, see Delete /// an Amazon EBS volume in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the DeleteVolume service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVolume service method, as returned by EC2. /// REST API Reference for DeleteVolume Operation Task DeleteVolumeAsync(DeleteVolumeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVpc ///

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

/// Container for the necessary parameters to execute the DeleteVpc service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVpc service method, as returned by EC2. /// REST API Reference for DeleteVpc Operation Task DeleteVpcAsync(DeleteVpcRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVpcEndpointConnectionNotifications ///

/// Deletes the specified VPC endpoint connection notifications. ///

/// Container for the necessary parameters to execute the DeleteVpcEndpointConnectionNotifications service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVpcEndpointConnectionNotifications service method, as returned by EC2. /// REST API Reference for DeleteVpcEndpointConnectionNotifications Operation Task DeleteVpcEndpointConnectionNotificationsAsync(DeleteVpcEndpointConnectionNotificationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVpcEndpoints ///

/// Deletes the specified VPC endpoints. /// /// /// /// When you delete a gateway endpoint, we delete the endpoint routes in the route tables /// for the endpoint. /// /// /// /// When you delete a Gateway Load Balancer endpoint, we delete its endpoint network interfaces. /// You can only delete Gateway Load Balancer endpoints when the routes that are associated /// with the endpoint are deleted. /// /// /// /// When you delete an interface endpoint, we delete its endpoint network interfaces. /// ///

/// Container for the necessary parameters to execute the DeleteVpcEndpoints service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVpcEndpoints service method, as returned by EC2. /// REST API Reference for DeleteVpcEndpoints Operation Task DeleteVpcEndpointsAsync(DeleteVpcEndpointsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVpcEndpointServiceConfigurations ///

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

/// Container for the necessary parameters to execute the DeleteVpcEndpointServiceConfigurations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVpcEndpointServiceConfigurations service method, as returned by EC2. /// REST API Reference for DeleteVpcEndpointServiceConfigurations Operation Task DeleteVpcEndpointServiceConfigurationsAsync(DeleteVpcEndpointServiceConfigurationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVpcPeeringConnection ///

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

/// Container for the necessary parameters to execute the DeleteVpcPeeringConnection service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVpcPeeringConnection service method, as returned by EC2. /// REST API Reference for DeleteVpcPeeringConnection Operation Task DeleteVpcPeeringConnectionAsync(DeleteVpcPeeringConnectionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVpnConnection ///

/// Deletes the specified VPN connection. /// /// /// /// If you're deleting the VPC and its associated components, we recommend that you detach /// the virtual private gateway from the VPC and delete the VPC before deleting the VPN /// connection. If you believe that the tunnel credentials for your VPN connection have /// been compromised, you can delete the VPN connection and create a new one that has /// new keys, without needing to delete the VPC or virtual private gateway. If you create /// a new VPN connection, you must reconfigure the customer gateway device using the new /// configuration information returned with the new VPN connection ID. /// /// /// /// For certificate-based authentication, delete all Certificate Manager (ACM) private /// certificates used for the Amazon Web Services-side tunnel endpoints for the VPN connection /// before deleting the VPN connection. /// ///

/// Container for the necessary parameters to execute the DeleteVpnConnection service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVpnConnection service method, as returned by EC2. /// REST API Reference for DeleteVpnConnection Operation Task DeleteVpnConnectionAsync(DeleteVpnConnectionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVpnConnectionRoute ///

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

/// Container for the necessary parameters to execute the DeleteVpnConnectionRoute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVpnConnectionRoute service method, as returned by EC2. /// REST API Reference for DeleteVpnConnectionRoute Operation Task DeleteVpnConnectionRouteAsync(DeleteVpnConnectionRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeleteVpnGateway ///

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

/// Container for the necessary parameters to execute the DeleteVpnGateway service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteVpnGateway service method, as returned by EC2. /// REST API Reference for DeleteVpnGateway Operation Task DeleteVpnGatewayAsync(DeleteVpnGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeprovisionByoipCidr ///

/// Releases the specified address range that you provisioned for use with your Amazon /// Web Services resources through bring your own IP addresses (BYOIP) and deletes the /// corresponding address pool. /// /// /// /// Before you can release an address range, you must stop advertising it using WithdrawByoipCidr /// and you must not have any IP addresses allocated from its address range. /// ///

/// Container for the necessary parameters to execute the DeprovisionByoipCidr service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeprovisionByoipCidr service method, as returned by EC2. /// REST API Reference for DeprovisionByoipCidr Operation Task DeprovisionByoipCidrAsync(DeprovisionByoipCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeprovisionIpamPoolCidr ///

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

/// Container for the necessary parameters to execute the DeprovisionIpamPoolCidr service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeprovisionIpamPoolCidr service method, as returned by EC2. /// REST API Reference for DeprovisionIpamPoolCidr Operation Task DeprovisionIpamPoolCidrAsync(DeprovisionIpamPoolCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeprovisionPublicIpv4PoolCidr ///

/// Deprovision a CIDR from a public IPv4 pool. ///

/// Container for the necessary parameters to execute the DeprovisionPublicIpv4PoolCidr service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeprovisionPublicIpv4PoolCidr service method, as returned by EC2. /// REST API Reference for DeprovisionPublicIpv4PoolCidr Operation Task DeprovisionPublicIpv4PoolCidrAsync(DeprovisionPublicIpv4PoolCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeregisterImage ///

/// Deregisters the specified AMI. After you deregister an AMI, it can't be used to launch /// new instances. /// /// /// /// If you deregister an AMI that matches a Recycle Bin retention rule, the AMI is retained /// in the Recycle Bin for the specified retention period. For more information, see Recycle /// Bin in the Amazon EC2 User Guide. /// /// /// /// When you deregister an AMI, it doesn't affect any instances that you've already launched /// from the AMI. You'll continue to incur usage costs for those instances until you terminate /// them. /// /// /// /// When you deregister an Amazon EBS-backed AMI, it doesn't affect the snapshot that /// was created for the root volume of the instance during the AMI creation process. When /// you deregister an instance store-backed AMI, it doesn't affect the files that you /// uploaded to Amazon S3 when you created the AMI. /// ///

/// Container for the necessary parameters to execute the DeregisterImage service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterImage service method, as returned by EC2. /// REST API Reference for DeregisterImage Operation Task DeregisterImageAsync(DeregisterImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeregisterInstanceEventNotificationAttributes ///

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

/// Container for the necessary parameters to execute the DeregisterInstanceEventNotificationAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterInstanceEventNotificationAttributes service method, as returned by EC2. /// REST API Reference for DeregisterInstanceEventNotificationAttributes Operation Task DeregisterInstanceEventNotificationAttributesAsync(DeregisterInstanceEventNotificationAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeregisterTransitGatewayMulticastGroupMembers ///

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

/// Container for the necessary parameters to execute the DeregisterTransitGatewayMulticastGroupMembers service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterTransitGatewayMulticastGroupMembers service method, as returned by EC2. /// REST API Reference for DeregisterTransitGatewayMulticastGroupMembers Operation Task DeregisterTransitGatewayMulticastGroupMembersAsync(DeregisterTransitGatewayMulticastGroupMembersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DeregisterTransitGatewayMulticastGroupSources ///

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

/// Container for the necessary parameters to execute the DeregisterTransitGatewayMulticastGroupSources service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterTransitGatewayMulticastGroupSources service method, as returned by EC2. /// REST API Reference for DeregisterTransitGatewayMulticastGroupSources Operation Task DeregisterTransitGatewayMulticastGroupSourcesAsync(DeregisterTransitGatewayMulticastGroupSourcesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeAccountAttributes ///

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

/// /// default-vpc: The ID of the default VPC for your account, or none. /// ///
/// /// max-instances: This attribute is no longer supported. The returned value /// does not reflect your actual vCPU limit for running On-Demand Instances. For more /// information, see On-Demand /// Instance Limits in the Amazon Elastic Compute Cloud User Guide. /// ///
/// /// max-elastic-ips: The maximum number of Elastic IP addresses that you /// can allocate. /// ///
/// /// supported-platforms: This attribute is deprecated. /// ///
/// /// vpc-max-elastic-ips: The maximum number of Elastic IP addresses that /// you can allocate. /// ///
/// /// vpc-max-security-groups-per-interface: The maximum number of security /// groups that you can assign to a network interface. /// ///

///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAccountAttributes service method, as returned by EC2. /// REST API Reference for DescribeAccountAttributes Operation Task DescribeAccountAttributesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

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

/// /// default-vpc: The ID of the default VPC for your account, or none. /// ///
/// /// max-instances: This attribute is no longer supported. The returned value /// does not reflect your actual vCPU limit for running On-Demand Instances. For more /// information, see On-Demand /// Instance Limits in the Amazon Elastic Compute Cloud User Guide. /// ///
/// /// max-elastic-ips: The maximum number of Elastic IP addresses that you /// can allocate. /// ///
/// /// supported-platforms: This attribute is deprecated. /// ///
/// /// vpc-max-elastic-ips: The maximum number of Elastic IP addresses that /// you can allocate. /// ///
/// /// vpc-max-security-groups-per-interface: The maximum number of security /// groups that you can assign to a network interface. /// ///

///

/// Container for the necessary parameters to execute the DescribeAccountAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAccountAttributes service method, as returned by EC2. /// REST API Reference for DescribeAccountAttributes Operation Task DescribeAccountAttributesAsync(DescribeAccountAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeAddresses ///

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

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAddresses service method, as returned by EC2. /// REST API Reference for DescribeAddresses Operation Task DescribeAddressesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

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

/// Container for the necessary parameters to execute the DescribeAddresses service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAddresses service method, as returned by EC2. /// REST API Reference for DescribeAddresses Operation Task DescribeAddressesAsync(DescribeAddressesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeAddressesAttribute ///

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

/// Container for the necessary parameters to execute the DescribeAddressesAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAddressesAttribute service method, as returned by EC2. /// REST API Reference for DescribeAddressesAttribute Operation Task DescribeAddressesAttributeAsync(DescribeAddressesAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeAddressTransfers ///

/// Describes an Elastic IP address transfer. For more information, see Transfer /// Elastic IP addresses in the Amazon Virtual Private Cloud User Guide. /// /// /// /// When you transfer an Elastic IP address, there is a two-step handshake between the /// source and transfer Amazon Web Services accounts. When the source account starts the /// transfer, the transfer account has seven days to accept the Elastic IP address transfer. /// During those seven days, the source account can view the pending transfer by using /// this action. After seven days, the transfer expires and ownership of the Elastic IP /// address returns to the source account. Accepted transfers are visible to the source /// account for three days after the transfers have been accepted. /// ///

/// Container for the necessary parameters to execute the DescribeAddressTransfers service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAddressTransfers service method, as returned by EC2. /// REST API Reference for DescribeAddressTransfers Operation Task DescribeAddressTransfersAsync(DescribeAddressTransfersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeAggregateIdFormat ///

/// Container for the necessary parameters to execute the DescribeAggregateIdFormat service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAggregateIdFormat service method, as returned by EC2. /// REST API Reference for DescribeAggregateIdFormat Operation Task DescribeAggregateIdFormatAsync(DescribeAggregateIdFormatRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeAvailabilityZones ///

/// Describes the Availability Zones, Local Zones, and Wavelength Zones that are available /// to you. If there is an event impacting a zone, you can use this request to view the /// state and any provided messages for that zone. /// /// /// /// For more information about Availability Zones, Local Zones, and Wavelength Zones, /// see Regions /// and zones in the Amazon Elastic Compute Cloud User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAvailabilityZones service method, as returned by EC2. /// REST API Reference for DescribeAvailabilityZones Operation Task DescribeAvailabilityZonesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeAvailabilityZones service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAvailabilityZones service method, as returned by EC2. /// REST API Reference for DescribeAvailabilityZones Operation Task DescribeAvailabilityZonesAsync(DescribeAvailabilityZonesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeAwsNetworkPerformanceMetricSubscriptions ///

/// Describes the current Infrastructure Performance metric subscriptions. ///

/// Container for the necessary parameters to execute the DescribeAwsNetworkPerformanceMetricSubscriptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAwsNetworkPerformanceMetricSubscriptions service method, as returned by EC2. /// REST API Reference for DescribeAwsNetworkPerformanceMetricSubscriptions Operation Task DescribeAwsNetworkPerformanceMetricSubscriptionsAsync(DescribeAwsNetworkPerformanceMetricSubscriptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeBundleTasks ///

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

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeBundleTasks service method, as returned by EC2. /// REST API Reference for DescribeBundleTasks Operation Task DescribeBundleTasksAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeBundleTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeBundleTasks service method, as returned by EC2. /// REST API Reference for DescribeBundleTasks Operation Task DescribeBundleTasksAsync(DescribeBundleTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeByoipCidrs ///

/// Describes the IP address ranges that were specified in calls to ProvisionByoipCidr. /// /// /// /// To describe the address pools that were created when you provisioned the address ranges, /// use DescribePublicIpv4Pools or DescribeIpv6Pools. /// ///

/// Container for the necessary parameters to execute the DescribeByoipCidrs service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeByoipCidrs service method, as returned by EC2. /// REST API Reference for DescribeByoipCidrs Operation Task DescribeByoipCidrsAsync(DescribeByoipCidrsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeCapacityReservationFleets ///

/// Describes one or more Capacity Reservation Fleets. ///

/// Container for the necessary parameters to execute the DescribeCapacityReservationFleets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCapacityReservationFleets service method, as returned by EC2. /// REST API Reference for DescribeCapacityReservationFleets Operation Task DescribeCapacityReservationFleetsAsync(DescribeCapacityReservationFleetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeCapacityReservations ///

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

/// Container for the necessary parameters to execute the DescribeCapacityReservations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCapacityReservations service method, as returned by EC2. /// REST API Reference for DescribeCapacityReservations Operation Task DescribeCapacityReservationsAsync(DescribeCapacityReservationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeCarrierGateways ///

/// Describes one or more of your carrier gateways. ///

/// Container for the necessary parameters to execute the DescribeCarrierGateways service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCarrierGateways service method, as returned by EC2. /// REST API Reference for DescribeCarrierGateways Operation Task DescribeCarrierGatewaysAsync(DescribeCarrierGatewaysRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeClassicLinkInstances ///

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

/// Container for the necessary parameters to execute the DescribeClassicLinkInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClassicLinkInstances service method, as returned by EC2. /// REST API Reference for DescribeClassicLinkInstances Operation Task DescribeClassicLinkInstancesAsync(DescribeClassicLinkInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeClientVpnAuthorizationRules ///

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

/// Container for the necessary parameters to execute the DescribeClientVpnAuthorizationRules service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClientVpnAuthorizationRules service method, as returned by EC2. /// REST API Reference for DescribeClientVpnAuthorizationRules Operation Task DescribeClientVpnAuthorizationRulesAsync(DescribeClientVpnAuthorizationRulesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeClientVpnConnections ///

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

/// Container for the necessary parameters to execute the DescribeClientVpnConnections service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClientVpnConnections service method, as returned by EC2. /// REST API Reference for DescribeClientVpnConnections Operation Task DescribeClientVpnConnectionsAsync(DescribeClientVpnConnectionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeClientVpnEndpoints ///

/// Describes one or more Client VPN endpoints in the account. ///

/// Container for the necessary parameters to execute the DescribeClientVpnEndpoints service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClientVpnEndpoints service method, as returned by EC2. /// REST API Reference for DescribeClientVpnEndpoints Operation Task DescribeClientVpnEndpointsAsync(DescribeClientVpnEndpointsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeClientVpnRoutes ///

/// Describes the routes for the specified Client VPN endpoint. ///

/// Container for the necessary parameters to execute the DescribeClientVpnRoutes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClientVpnRoutes service method, as returned by EC2. /// REST API Reference for DescribeClientVpnRoutes Operation Task DescribeClientVpnRoutesAsync(DescribeClientVpnRoutesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeClientVpnTargetNetworks ///

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

/// Container for the necessary parameters to execute the DescribeClientVpnTargetNetworks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeClientVpnTargetNetworks service method, as returned by EC2. /// REST API Reference for DescribeClientVpnTargetNetworks Operation Task DescribeClientVpnTargetNetworksAsync(DescribeClientVpnTargetNetworksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeCoipPools ///

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

/// Container for the necessary parameters to execute the DescribeCoipPools service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCoipPools service method, as returned by EC2. /// REST API Reference for DescribeCoipPools Operation Task DescribeCoipPoolsAsync(DescribeCoipPoolsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeConversionTasks ///

/// Describes the specified conversion tasks or all your conversion tasks. For more information, /// see the VM Import/Export /// User Guide. /// /// /// /// For information about the import manifest referenced by this API action, see VM /// Import Manifest. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeConversionTasks service method, as returned by EC2. /// REST API Reference for DescribeConversionTasks Operation Task DescribeConversionTasksAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeConversionTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeConversionTasks service method, as returned by EC2. /// REST API Reference for DescribeConversionTasks Operation Task DescribeConversionTasksAsync(DescribeConversionTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeCustomerGateways ///

/// Describes one or more of your VPN customer gateways. /// /// /// /// For more information, see Amazon /// Web Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN User /// Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCustomerGateways service method, as returned by EC2. /// REST API Reference for DescribeCustomerGateways Operation Task DescribeCustomerGatewaysAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeCustomerGateways service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCustomerGateways service method, as returned by EC2. /// REST API Reference for DescribeCustomerGateways Operation Task DescribeCustomerGatewaysAsync(DescribeCustomerGatewaysRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeDhcpOptions ///

/// Describes one or more of your DHCP options sets. /// /// /// /// For more information, see DHCP /// options sets in the Amazon VPC User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDhcpOptions service method, as returned by EC2. /// REST API Reference for DescribeDhcpOptions Operation Task DescribeDhcpOptionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes one or more of your DHCP options sets. /// /// /// /// For more information, see DHCP /// options sets in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeDhcpOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDhcpOptions service method, as returned by EC2. /// REST API Reference for DescribeDhcpOptions Operation Task DescribeDhcpOptionsAsync(DescribeDhcpOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeEgressOnlyInternetGateways ///

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

/// Container for the necessary parameters to execute the DescribeEgressOnlyInternetGateways service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEgressOnlyInternetGateways service method, as returned by EC2. /// REST API Reference for DescribeEgressOnlyInternetGateways Operation Task DescribeEgressOnlyInternetGatewaysAsync(DescribeEgressOnlyInternetGatewaysRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeElasticGpus ///

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

/// Container for the necessary parameters to execute the DescribeElasticGpus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeElasticGpus service method, as returned by EC2. /// REST API Reference for DescribeElasticGpus Operation Task DescribeElasticGpusAsync(DescribeElasticGpusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeExportImageTasks ///

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

/// Container for the necessary parameters to execute the DescribeExportImageTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeExportImageTasks service method, as returned by EC2. /// REST API Reference for DescribeExportImageTasks Operation Task DescribeExportImageTasksAsync(DescribeExportImageTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeExportTasks ///

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

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeExportTasks service method, as returned by EC2. /// REST API Reference for DescribeExportTasks Operation Task DescribeExportTasksAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

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

/// Container for the necessary parameters to execute the DescribeExportTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeExportTasks service method, as returned by EC2. /// REST API Reference for DescribeExportTasks Operation Task DescribeExportTasksAsync(DescribeExportTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeFastLaunchImages ///

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

/// Container for the necessary parameters to execute the DescribeFastLaunchImages service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeFastLaunchImages service method, as returned by EC2. /// REST API Reference for DescribeFastLaunchImages Operation Task DescribeFastLaunchImagesAsync(DescribeFastLaunchImagesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeFastSnapshotRestores ///

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

/// Container for the necessary parameters to execute the DescribeFastSnapshotRestores service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeFastSnapshotRestores service method, as returned by EC2. /// REST API Reference for DescribeFastSnapshotRestores Operation Task DescribeFastSnapshotRestoresAsync(DescribeFastSnapshotRestoresRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeFleetHistory ///

/// Describes the events for the specified EC2 Fleet during the specified time. /// /// /// /// EC2 Fleet events are delayed by up to 30 seconds before they can be described. This /// ensures that you can query by the last evaluated time and not miss a recorded event. /// EC2 Fleet events are available for 48 hours. /// /// /// /// For more information, see Monitor /// fleet events using Amazon EventBridge in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeFleetHistory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeFleetHistory service method, as returned by EC2. /// REST API Reference for DescribeFleetHistory Operation Task DescribeFleetHistoryAsync(DescribeFleetHistoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeFleetInstances ///

/// Describes the running instances for the specified EC2 Fleet. /// /// /// /// For more information, see Monitor /// your EC2 Fleet in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeFleetInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeFleetInstances service method, as returned by EC2. /// REST API Reference for DescribeFleetInstances Operation Task DescribeFleetInstancesAsync(DescribeFleetInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeFleets ///

/// Describes the specified EC2 Fleets or all of your EC2 Fleets. /// /// /// /// For more information, see Monitor /// your EC2 Fleet in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeFleets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeFleets service method, as returned by EC2. /// REST API Reference for DescribeFleets Operation Task DescribeFleetsAsync(DescribeFleetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeFlowLogs ///

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

/// Container for the necessary parameters to execute the DescribeFlowLogs service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeFlowLogs service method, as returned by EC2. /// REST API Reference for DescribeFlowLogs Operation Task DescribeFlowLogsAsync(DescribeFlowLogsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeFpgaImageAttribute ///

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

/// Container for the necessary parameters to execute the DescribeFpgaImageAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeFpgaImageAttribute service method, as returned by EC2. /// REST API Reference for DescribeFpgaImageAttribute Operation Task DescribeFpgaImageAttributeAsync(DescribeFpgaImageAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeFpgaImages ///

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

/// Container for the necessary parameters to execute the DescribeFpgaImages service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeFpgaImages service method, as returned by EC2. /// REST API Reference for DescribeFpgaImages Operation Task DescribeFpgaImagesAsync(DescribeFpgaImagesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeHostReservationOfferings ///

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

/// Container for the necessary parameters to execute the DescribeHostReservationOfferings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeHostReservationOfferings service method, as returned by EC2. /// REST API Reference for DescribeHostReservationOfferings Operation Task DescribeHostReservationOfferingsAsync(DescribeHostReservationOfferingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeHostReservations ///

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

/// Container for the necessary parameters to execute the DescribeHostReservations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeHostReservations service method, as returned by EC2. /// REST API Reference for DescribeHostReservations Operation Task DescribeHostReservationsAsync(DescribeHostReservationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeHosts ///

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

/// Container for the necessary parameters to execute the DescribeHosts service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeHosts service method, as returned by EC2. /// REST API Reference for DescribeHosts Operation Task DescribeHostsAsync(DescribeHostsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeIamInstanceProfileAssociations ///

/// Describes your IAM instance profile associations. ///

/// Container for the necessary parameters to execute the DescribeIamInstanceProfileAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIamInstanceProfileAssociations service method, as returned by EC2. /// REST API Reference for DescribeIamInstanceProfileAssociations Operation Task DescribeIamInstanceProfileAssociationsAsync(DescribeIamInstanceProfileAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeIdentityIdFormat ///

/// Container for the necessary parameters to execute the DescribeIdentityIdFormat service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIdentityIdFormat service method, as returned by EC2. /// REST API Reference for DescribeIdentityIdFormat Operation Task DescribeIdentityIdFormatAsync(DescribeIdentityIdFormatRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeIdFormat ///

/// Describes the ID format settings for your resources on a per-Region basis, for example, /// to view which resource types are enabled for longer IDs. This request only returns /// information about resource types whose ID formats can be modified; it does not return /// information about other resource types. /// /// /// /// The following resource types support longer IDs: bundle | conversion-task /// | customer-gateway | dhcp-options | elastic-ip-allocation /// | elastic-ip-association | export-task | flow-log /// | image | import-task | instance | internet-gateway /// | network-acl | network-acl-association | network-interface /// | network-interface-attachment | prefix-list | reservation /// | route-table | route-table-association | security-group /// | snapshot | subnet | subnet-cidr-block-association /// | volume | vpc | vpc-cidr-block-association /// | vpc-endpoint | vpc-peering-connection | vpn-connection /// | vpn-gateway. /// /// /// /// These settings apply to the IAM user who makes the request; they do not apply to the /// entire Amazon Web Services account. By default, an IAM user defaults to the same settings /// as the root user, unless they explicitly override the settings by running the ModifyIdFormat /// command. Resources created with longer IDs are visible to all IAM users, regardless /// of these settings and provided that they have permission to use the relevant Describe /// command for the resource type. /// ///

/// Container for the necessary parameters to execute the DescribeIdFormat service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIdFormat service method, as returned by EC2. /// REST API Reference for DescribeIdFormat Operation Task DescribeIdFormatAsync(DescribeIdFormatRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeImageAttribute ///

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

/// Container for the necessary parameters to execute the DescribeImageAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeImageAttribute service method, as returned by EC2. /// REST API Reference for DescribeImageAttribute Operation Task DescribeImageAttributeAsync(DescribeImageAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeImages ///

/// Describes the specified images (AMIs, AKIs, and ARIs) available to you or all of the /// images available to you. /// /// /// /// The images available to you include public images, private images that you own, and /// private images owned by other Amazon Web Services accounts for which you have explicit /// launch permissions. /// /// /// /// Recently deregistered images appear in the returned results for a short interval and /// then return empty results. After all instances that reference a deregistered AMI are /// terminated, specifying the ID of the image will eventually return an error indicating /// that the AMI ID cannot be found. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeImages service method, as returned by EC2. /// REST API Reference for DescribeImages Operation Task DescribeImagesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeImages service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeImages service method, as returned by EC2. /// REST API Reference for DescribeImages Operation Task DescribeImagesAsync(DescribeImagesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeImportImageTasks ///

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

/// Container for the necessary parameters to execute the DescribeImportImageTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeImportImageTasks service method, as returned by EC2. /// REST API Reference for DescribeImportImageTasks Operation Task DescribeImportImageTasksAsync(DescribeImportImageTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeImportSnapshotTasks ///

/// Describes your import snapshot tasks. ///

/// Container for the necessary parameters to execute the DescribeImportSnapshotTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeImportSnapshotTasks service method, as returned by EC2. /// REST API Reference for DescribeImportSnapshotTasks Operation Task DescribeImportSnapshotTasksAsync(DescribeImportSnapshotTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstanceAttribute ///

/// Container for the necessary parameters to execute the DescribeInstanceAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceAttribute service method, as returned by EC2. /// REST API Reference for DescribeInstanceAttribute Operation Task DescribeInstanceAttributeAsync(DescribeInstanceAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstanceConnectEndpoints ///

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

/// Container for the necessary parameters to execute the DescribeInstanceConnectEndpoints service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceConnectEndpoints service method, as returned by EC2. /// REST API Reference for DescribeInstanceConnectEndpoints Operation Task DescribeInstanceConnectEndpointsAsync(DescribeInstanceConnectEndpointsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstanceCreditSpecifications ///

/// Describes the credit option for CPU usage of the specified burstable performance instances. /// The credit options are standard and unlimited. /// /// /// /// If you do not specify an instance ID, Amazon EC2 returns burstable performance instances /// with the unlimited credit option, as well as instances that were previously /// configured as T2, T3, and T3a with the unlimited credit option. For example, /// if you resize a T2 instance, while it is configured as unlimited, to /// an M4 instance, Amazon EC2 returns the M4 instance. /// /// /// /// If you specify one or more instance IDs, Amazon EC2 returns the credit option (standard /// or unlimited) of those instances. If you specify an instance ID that /// is not valid, such as an instance that is not a burstable performance instance, an /// error is returned. /// /// /// /// Recently terminated instances might appear in the returned results. This interval /// is usually less than one hour. /// /// /// /// If an Availability Zone is experiencing a service disruption and you specify instance /// IDs in the affected zone, or do not specify any instance IDs at all, the call fails. /// If you specify only instance IDs in an unaffected zone, the call works normally. /// /// /// /// For more information, see Burstable /// performance instances in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeInstanceCreditSpecifications service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceCreditSpecifications service method, as returned by EC2. /// REST API Reference for DescribeInstanceCreditSpecifications Operation Task DescribeInstanceCreditSpecificationsAsync(DescribeInstanceCreditSpecificationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstanceEventNotificationAttributes ///

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

/// Container for the necessary parameters to execute the DescribeInstanceEventNotificationAttributes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceEventNotificationAttributes service method, as returned by EC2. /// REST API Reference for DescribeInstanceEventNotificationAttributes Operation Task DescribeInstanceEventNotificationAttributesAsync(DescribeInstanceEventNotificationAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstanceEventWindows ///

/// Describes the specified event windows or all event windows. /// /// /// /// If you specify event window IDs, the output includes information for only the specified /// event windows. If you specify filters, the output includes information for only those /// event windows that meet the filter criteria. If you do not specify event windows IDs /// or filters, the output includes information for all event windows, which can affect /// performance. We recommend that you use pagination to ensure that the operation returns /// quickly and successfully. /// /// /// /// For more information, see Define /// event windows for scheduled events in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeInstanceEventWindows service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceEventWindows service method, as returned by EC2. /// REST API Reference for DescribeInstanceEventWindows Operation Task DescribeInstanceEventWindowsAsync(DescribeInstanceEventWindowsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstances ///

/// Describes the specified instances or all instances. /// /// /// /// If you specify instance IDs, the output includes information for only the specified /// instances. If you specify filters, the output includes information for only those /// instances that meet the filter criteria. If you do not specify instance IDs or filters, /// the output includes information for all instances, which can affect performance. We /// recommend that you use pagination to ensure that the operation returns quickly and /// successfully. /// /// /// /// If you specify an instance ID that is not valid, an error is returned. If you specify /// an instance that you do not own, it is not included in the output. /// /// /// /// Recently terminated instances might appear in the returned results. This interval /// is usually less than one hour. /// /// /// /// If you describe instances in the rare case where an Availability Zone is experiencing /// a service disruption and you specify instance IDs that are in the affected zone, or /// do not specify any instance IDs at all, the call fails. If you describe instances /// and specify only instance IDs that are in an unaffected zone, the call works normally. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstances service method, as returned by EC2. /// REST API Reference for DescribeInstances Operation Task DescribeInstancesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstances service method, as returned by EC2. /// REST API Reference for DescribeInstances Operation Task DescribeInstancesAsync(DescribeInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstanceStatus ///

/// Describes the status of the specified instances or all of your instances. By default, /// only running instances are described, unless you specifically indicate to return the /// status of all instances. /// /// /// /// Instance status includes the following components: /// ///

/// /// Status checks - Amazon EC2 performs status checks on running EC2 instances /// to identify hardware and software issues. For more information, see Status /// checks for your instances and Troubleshoot /// instances with failed status checks in the Amazon EC2 User Guide. /// ///
/// /// Scheduled events - Amazon EC2 can schedule events (such as reboot, stop, or /// terminate) for your instances related to hardware issues, software updates, or system /// maintenance. For more information, see Scheduled /// events for your instances in the Amazon EC2 User Guide. /// ///
/// /// Instance state - You can manage your instances from the moment you launch /// them through their termination. For more information, see Instance /// lifecycle in the Amazon EC2 User Guide. /// ///

///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceStatus service method, as returned by EC2. /// REST API Reference for DescribeInstanceStatus Operation Task DescribeInstanceStatusAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// /// Status checks - Amazon EC2 performs status checks on running EC2 instances /// to identify hardware and software issues. For more information, see Status /// checks for your instances and Troubleshoot /// instances with failed status checks in the Amazon EC2 User Guide. /// ///
/// /// Scheduled events - Amazon EC2 can schedule events (such as reboot, stop, or /// terminate) for your instances related to hardware issues, software updates, or system /// maintenance. For more information, see Scheduled /// events for your instances in the Amazon EC2 User Guide. /// ///
/// /// Instance state - You can manage your instances from the moment you launch /// them through their termination. For more information, see Instance /// lifecycle in the Amazon EC2 User Guide. /// ///

///

/// Container for the necessary parameters to execute the DescribeInstanceStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceStatus service method, as returned by EC2. /// REST API Reference for DescribeInstanceStatus Operation Task DescribeInstanceStatusAsync(DescribeInstanceStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstanceTypeOfferings ///

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

/// Container for the necessary parameters to execute the DescribeInstanceTypeOfferings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceTypeOfferings service method, as returned by EC2. /// REST API Reference for DescribeInstanceTypeOfferings Operation Task DescribeInstanceTypeOfferingsAsync(DescribeInstanceTypeOfferingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInstanceTypes ///

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

/// Container for the necessary parameters to execute the DescribeInstanceTypes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceTypes service method, as returned by EC2. /// REST API Reference for DescribeInstanceTypes Operation Task DescribeInstanceTypesAsync(DescribeInstanceTypesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeInternetGateways ///

/// Describes one or more of your internet gateways. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInternetGateways service method, as returned by EC2. /// REST API Reference for DescribeInternetGateways Operation Task DescribeInternetGatewaysAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes one or more of your internet gateways. ///

/// Container for the necessary parameters to execute the DescribeInternetGateways service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInternetGateways service method, as returned by EC2. /// REST API Reference for DescribeInternetGateways Operation Task DescribeInternetGatewaysAsync(DescribeInternetGatewaysRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeIpamPools ///

/// Get information about your IPAM pools. ///

/// Container for the necessary parameters to execute the DescribeIpamPools service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIpamPools service method, as returned by EC2. /// REST API Reference for DescribeIpamPools Operation Task DescribeIpamPoolsAsync(DescribeIpamPoolsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeIpamResourceDiscoveries ///

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

/// Container for the necessary parameters to execute the DescribeIpamResourceDiscoveries service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIpamResourceDiscoveries service method, as returned by EC2. /// REST API Reference for DescribeIpamResourceDiscoveries Operation Task DescribeIpamResourceDiscoveriesAsync(DescribeIpamResourceDiscoveriesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeIpamResourceDiscoveryAssociations ///

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

/// Container for the necessary parameters to execute the DescribeIpamResourceDiscoveryAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIpamResourceDiscoveryAssociations service method, as returned by EC2. /// REST API Reference for DescribeIpamResourceDiscoveryAssociations Operation Task DescribeIpamResourceDiscoveryAssociationsAsync(DescribeIpamResourceDiscoveryAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeIpams ///

/// Get information about your IPAM pools. /// /// /// /// For more information, see What /// is IPAM? in the Amazon VPC IPAM User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeIpams service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIpams service method, as returned by EC2. /// REST API Reference for DescribeIpams Operation Task DescribeIpamsAsync(DescribeIpamsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeIpamScopes ///

/// Get information about your IPAM scopes. ///

/// Container for the necessary parameters to execute the DescribeIpamScopes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIpamScopes service method, as returned by EC2. /// REST API Reference for DescribeIpamScopes Operation Task DescribeIpamScopesAsync(DescribeIpamScopesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeIpv6Pools ///

/// Describes your IPv6 address pools. ///

/// Container for the necessary parameters to execute the DescribeIpv6Pools service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIpv6Pools service method, as returned by EC2. /// REST API Reference for DescribeIpv6Pools Operation Task DescribeIpv6PoolsAsync(DescribeIpv6PoolsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeKeyPairs ///

/// Describes the specified key pairs or all of your key pairs. /// /// /// /// For more information about key pairs, see Amazon /// EC2 key pairs in the Amazon Elastic Compute Cloud User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeKeyPairs service method, as returned by EC2. /// REST API Reference for DescribeKeyPairs Operation Task DescribeKeyPairsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeKeyPairs service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeKeyPairs service method, as returned by EC2. /// REST API Reference for DescribeKeyPairs Operation Task DescribeKeyPairsAsync(DescribeKeyPairsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLaunchTemplates ///

/// Describes one or more launch templates. ///

/// Container for the necessary parameters to execute the DescribeLaunchTemplates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLaunchTemplates service method, as returned by EC2. /// REST API Reference for DescribeLaunchTemplates Operation Task DescribeLaunchTemplatesAsync(DescribeLaunchTemplatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLaunchTemplateVersions ///

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

/// Container for the necessary parameters to execute the DescribeLaunchTemplateVersions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLaunchTemplateVersions service method, as returned by EC2. /// REST API Reference for DescribeLaunchTemplateVersions Operation Task DescribeLaunchTemplateVersionsAsync(DescribeLaunchTemplateVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLocalGatewayRouteTables ///

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

/// Container for the necessary parameters to execute the DescribeLocalGatewayRouteTables service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLocalGatewayRouteTables service method, as returned by EC2. /// REST API Reference for DescribeLocalGatewayRouteTables Operation Task DescribeLocalGatewayRouteTablesAsync(DescribeLocalGatewayRouteTablesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations ///

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

/// Container for the necessary parameters to execute the DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations service method, as returned by EC2. /// REST API Reference for DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations Operation Task DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsAsync(DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLocalGatewayRouteTableVpcAssociations ///

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

/// Container for the necessary parameters to execute the DescribeLocalGatewayRouteTableVpcAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLocalGatewayRouteTableVpcAssociations service method, as returned by EC2. /// REST API Reference for DescribeLocalGatewayRouteTableVpcAssociations Operation Task DescribeLocalGatewayRouteTableVpcAssociationsAsync(DescribeLocalGatewayRouteTableVpcAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLocalGateways ///

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

/// Container for the necessary parameters to execute the DescribeLocalGateways service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLocalGateways service method, as returned by EC2. /// REST API Reference for DescribeLocalGateways Operation Task DescribeLocalGatewaysAsync(DescribeLocalGatewaysRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLocalGatewayVirtualInterfaceGroups ///

/// Describes the specified local gateway virtual interface groups. ///

/// Container for the necessary parameters to execute the DescribeLocalGatewayVirtualInterfaceGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLocalGatewayVirtualInterfaceGroups service method, as returned by EC2. /// REST API Reference for DescribeLocalGatewayVirtualInterfaceGroups Operation Task DescribeLocalGatewayVirtualInterfaceGroupsAsync(DescribeLocalGatewayVirtualInterfaceGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeLocalGatewayVirtualInterfaces ///

/// Describes the specified local gateway virtual interfaces. ///

/// Container for the necessary parameters to execute the DescribeLocalGatewayVirtualInterfaces service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeLocalGatewayVirtualInterfaces service method, as returned by EC2. /// REST API Reference for DescribeLocalGatewayVirtualInterfaces Operation Task DescribeLocalGatewayVirtualInterfacesAsync(DescribeLocalGatewayVirtualInterfacesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeManagedPrefixLists ///

/// Describes your managed prefix lists and any Amazon Web Services-managed prefix lists. /// /// /// /// To view the entries for your prefix list, use GetManagedPrefixListEntries. /// ///

/// Container for the necessary parameters to execute the DescribeManagedPrefixLists service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeManagedPrefixLists service method, as returned by EC2. /// REST API Reference for DescribeManagedPrefixLists Operation Task DescribeManagedPrefixListsAsync(DescribeManagedPrefixListsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeMovingAddresses ///

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

/// Container for the necessary parameters to execute the DescribeMovingAddresses service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMovingAddresses service method, as returned by EC2. /// REST API Reference for DescribeMovingAddresses Operation Task DescribeMovingAddressesAsync(DescribeMovingAddressesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeNatGateways ///

/// Describes one or more of your NAT gateways. ///

/// Container for the necessary parameters to execute the DescribeNatGateways service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNatGateways service method, as returned by EC2. /// REST API Reference for DescribeNatGateways Operation Task DescribeNatGatewaysAsync(DescribeNatGatewaysRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeNetworkAcls ///

/// Describes one or more of your network ACLs. /// /// /// /// For more information, see Network /// ACLs in the Amazon VPC User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkAcls service method, as returned by EC2. /// REST API Reference for DescribeNetworkAcls Operation Task DescribeNetworkAclsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes one or more of your network ACLs. /// /// /// /// For more information, see Network /// ACLs in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeNetworkAcls service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkAcls service method, as returned by EC2. /// REST API Reference for DescribeNetworkAcls Operation Task DescribeNetworkAclsAsync(DescribeNetworkAclsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeNetworkInsightsAccessScopeAnalyses ///

/// Describes the specified Network Access Scope analyses. ///

/// Container for the necessary parameters to execute the DescribeNetworkInsightsAccessScopeAnalyses service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkInsightsAccessScopeAnalyses service method, as returned by EC2. /// REST API Reference for DescribeNetworkInsightsAccessScopeAnalyses Operation Task DescribeNetworkInsightsAccessScopeAnalysesAsync(DescribeNetworkInsightsAccessScopeAnalysesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeNetworkInsightsAccessScopes ///

/// Describes the specified Network Access Scopes. ///

/// Container for the necessary parameters to execute the DescribeNetworkInsightsAccessScopes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkInsightsAccessScopes service method, as returned by EC2. /// REST API Reference for DescribeNetworkInsightsAccessScopes Operation Task DescribeNetworkInsightsAccessScopesAsync(DescribeNetworkInsightsAccessScopesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeNetworkInsightsAnalyses ///

/// Describes one or more of your network insights analyses. ///

/// Container for the necessary parameters to execute the DescribeNetworkInsightsAnalyses service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkInsightsAnalyses service method, as returned by EC2. /// REST API Reference for DescribeNetworkInsightsAnalyses Operation Task DescribeNetworkInsightsAnalysesAsync(DescribeNetworkInsightsAnalysesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeNetworkInsightsPaths ///

/// Describes one or more of your paths. ///

/// Container for the necessary parameters to execute the DescribeNetworkInsightsPaths service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkInsightsPaths service method, as returned by EC2. /// REST API Reference for DescribeNetworkInsightsPaths Operation Task DescribeNetworkInsightsPathsAsync(DescribeNetworkInsightsPathsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeNetworkInterfaceAttribute ///

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

/// Container for the necessary parameters to execute the DescribeNetworkInterfaceAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkInterfaceAttribute service method, as returned by EC2. /// REST API Reference for DescribeNetworkInterfaceAttribute Operation Task DescribeNetworkInterfaceAttributeAsync(DescribeNetworkInterfaceAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeNetworkInterfacePermissions ///

/// Describes the permissions for your network interfaces. ///

/// Container for the necessary parameters to execute the DescribeNetworkInterfacePermissions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkInterfacePermissions service method, as returned by EC2. /// REST API Reference for DescribeNetworkInterfacePermissions Operation Task DescribeNetworkInterfacePermissionsAsync(DescribeNetworkInterfacePermissionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeNetworkInterfaces ///

/// Describes one or more of your network interfaces. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkInterfaces service method, as returned by EC2. /// REST API Reference for DescribeNetworkInterfaces Operation Task DescribeNetworkInterfacesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes one or more of your network interfaces. ///

/// Container for the necessary parameters to execute the DescribeNetworkInterfaces service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeNetworkInterfaces service method, as returned by EC2. /// REST API Reference for DescribeNetworkInterfaces Operation Task DescribeNetworkInterfacesAsync(DescribeNetworkInterfacesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribePlacementGroups ///

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

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePlacementGroups service method, as returned by EC2. /// REST API Reference for DescribePlacementGroups Operation Task DescribePlacementGroupsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

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

/// Container for the necessary parameters to execute the DescribePlacementGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePlacementGroups service method, as returned by EC2. /// REST API Reference for DescribePlacementGroups Operation Task DescribePlacementGroupsAsync(DescribePlacementGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribePrefixLists ///

/// Describes available Amazon Web Services services in a prefix list format, which includes /// the prefix list name and prefix list ID of the service and the IP address range for /// the service. /// /// /// /// We recommend that you use DescribeManagedPrefixLists instead. /// ///

/// Container for the necessary parameters to execute the DescribePrefixLists service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePrefixLists service method, as returned by EC2. /// REST API Reference for DescribePrefixLists Operation Task DescribePrefixListsAsync(DescribePrefixListsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribePrincipalIdFormat ///

/// Container for the necessary parameters to execute the DescribePrincipalIdFormat service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePrincipalIdFormat service method, as returned by EC2. /// REST API Reference for DescribePrincipalIdFormat Operation Task DescribePrincipalIdFormatAsync(DescribePrincipalIdFormatRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribePublicIpv4Pools ///

/// Describes the specified IPv4 address pools. ///

/// Container for the necessary parameters to execute the DescribePublicIpv4Pools service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePublicIpv4Pools service method, as returned by EC2. /// REST API Reference for DescribePublicIpv4Pools Operation Task DescribePublicIpv4PoolsAsync(DescribePublicIpv4PoolsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeRegions ///

/// Describes the Regions that are enabled for your account, or all Regions. /// /// /// /// For a list of the Regions supported by Amazon EC2, see /// Amazon Elastic Compute Cloud endpoints and quotas. /// /// /// /// For information about enabling and disabling Regions for your account, see Managing /// Amazon Web Services Regions in the Amazon Web Services General Reference. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeRegions service method, as returned by EC2. /// REST API Reference for DescribeRegions Operation Task DescribeRegionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeRegions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeRegions service method, as returned by EC2. /// REST API Reference for DescribeRegions Operation Task DescribeRegionsAsync(DescribeRegionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeReplaceRootVolumeTasks ///

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

/// Container for the necessary parameters to execute the DescribeReplaceRootVolumeTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReplaceRootVolumeTasks service method, as returned by EC2. /// REST API Reference for DescribeReplaceRootVolumeTasks Operation Task DescribeReplaceRootVolumeTasksAsync(DescribeReplaceRootVolumeTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeReservedInstances ///

/// Describes one or more of the Reserved Instances that you purchased. /// /// /// /// For more information about Reserved Instances, see Reserved /// Instances in the Amazon EC2 User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedInstances service method, as returned by EC2. /// REST API Reference for DescribeReservedInstances Operation Task DescribeReservedInstancesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeReservedInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedInstances service method, as returned by EC2. /// REST API Reference for DescribeReservedInstances Operation Task DescribeReservedInstancesAsync(DescribeReservedInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeReservedInstancesListings ///

/// Describes your account's Reserved Instance listings in the Reserved Instance Marketplace. /// /// /// /// The Reserved Instance Marketplace matches sellers who want to resell Reserved Instance /// capacity that they no longer need with buyers who want to purchase additional capacity. /// Reserved Instances bought and sold through the Reserved Instance Marketplace work /// like any other Reserved Instances. /// /// /// /// As a seller, you choose to list some or all of your Reserved Instances, and you specify /// the upfront price to receive for them. Your Reserved Instances are then listed in /// the Reserved Instance Marketplace and are available for purchase. /// /// /// /// As a buyer, you specify the configuration of the Reserved Instance to purchase, and /// the Marketplace matches what you're searching for with what's available. The Marketplace /// first sells the lowest priced Reserved Instances to you, and continues to sell available /// Reserved Instance listings to you until your demand is met. You are charged based /// on the total price of all of the listings that you purchase. /// /// /// /// For more information, see Reserved /// Instance Marketplace in the Amazon EC2 User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedInstancesListings service method, as returned by EC2. /// REST API Reference for DescribeReservedInstancesListings Operation Task DescribeReservedInstancesListingsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeReservedInstancesListings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedInstancesListings service method, as returned by EC2. /// REST API Reference for DescribeReservedInstancesListings Operation Task DescribeReservedInstancesListingsAsync(DescribeReservedInstancesListingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeReservedInstancesModifications ///

/// Describes the modifications made to your Reserved Instances. If no parameter is specified, /// information about all your Reserved Instances modification requests is returned. If /// a modification ID is specified, only information about the specific modification is /// returned. /// /// /// /// For more information, see Modifying /// Reserved Instances in the Amazon EC2 User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedInstancesModifications service method, as returned by EC2. /// REST API Reference for DescribeReservedInstancesModifications Operation Task DescribeReservedInstancesModificationsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeReservedInstancesModifications service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedInstancesModifications service method, as returned by EC2. /// REST API Reference for DescribeReservedInstancesModifications Operation Task DescribeReservedInstancesModificationsAsync(DescribeReservedInstancesModificationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeReservedInstancesOfferings ///

/// Describes Reserved Instance offerings that are available for purchase. With Reserved /// Instances, you purchase the right to launch instances for a period of time. During /// that time period, you do not receive insufficient capacity errors, and you pay a lower /// usage rate than the rate charged for On-Demand instances for the actual time used. /// /// /// /// If you have listed your own Reserved Instances for sale in the Reserved Instance Marketplace, /// they will be excluded from these results. This is to ensure that you do not purchase /// your own Reserved Instances. /// /// /// /// For more information, see Reserved /// Instance Marketplace in the Amazon EC2 User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedInstancesOfferings service method, as returned by EC2. /// REST API Reference for DescribeReservedInstancesOfferings Operation Task DescribeReservedInstancesOfferingsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeReservedInstancesOfferings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeReservedInstancesOfferings service method, as returned by EC2. /// REST API Reference for DescribeReservedInstancesOfferings Operation Task DescribeReservedInstancesOfferingsAsync(DescribeReservedInstancesOfferingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeRouteTables ///

/// Describes one or more of your route tables. /// /// /// /// Each subnet in your VPC must be associated with a route table. If a subnet is not /// explicitly associated with any route table, it is implicitly associated with the main /// route table. This command does not return the subnet ID for implicit associations. /// /// /// /// For more information, see Route /// tables in the Amazon VPC User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeRouteTables service method, as returned by EC2. /// REST API Reference for DescribeRouteTables Operation Task DescribeRouteTablesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeRouteTables service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeRouteTables service method, as returned by EC2. /// REST API Reference for DescribeRouteTables Operation Task DescribeRouteTablesAsync(DescribeRouteTablesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeScheduledInstanceAvailability ///

/// Finds available schedules that meet the specified criteria. /// /// /// /// You can search for an available schedule no more than 3 months in advance. You must /// meet the minimum required duration of 1,200 hours per year. For example, the minimum /// daily schedule is 4 hours, the minimum weekly schedule is 24 hours, and the minimum /// monthly schedule is 100 hours. /// /// /// /// After you find a schedule that meets your needs, call PurchaseScheduledInstances /// to purchase Scheduled Instances with that schedule. /// ///

/// Container for the necessary parameters to execute the DescribeScheduledInstanceAvailability service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeScheduledInstanceAvailability service method, as returned by EC2. /// REST API Reference for DescribeScheduledInstanceAvailability Operation Task DescribeScheduledInstanceAvailabilityAsync(DescribeScheduledInstanceAvailabilityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeScheduledInstances ///

/// Describes the specified Scheduled Instances or all your Scheduled Instances. ///

/// Container for the necessary parameters to execute the DescribeScheduledInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeScheduledInstances service method, as returned by EC2. /// REST API Reference for DescribeScheduledInstances Operation Task DescribeScheduledInstancesAsync(DescribeScheduledInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSecurityGroupReferences ///

/// Describes the VPCs on the other side of a VPC peering connection that are referencing /// the security groups you've specified in this request. ///

/// Container for the necessary parameters to execute the DescribeSecurityGroupReferences service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSecurityGroupReferences service method, as returned by EC2. /// REST API Reference for DescribeSecurityGroupReferences Operation Task DescribeSecurityGroupReferencesAsync(DescribeSecurityGroupReferencesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSecurityGroupRules ///

/// Describes one or more of your security group rules. ///

/// Container for the necessary parameters to execute the DescribeSecurityGroupRules service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSecurityGroupRules service method, as returned by EC2. /// REST API Reference for DescribeSecurityGroupRules Operation Task DescribeSecurityGroupRulesAsync(DescribeSecurityGroupRulesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSecurityGroups ///

/// Describes the specified security groups or all of your security groups. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSecurityGroups service method, as returned by EC2. /// REST API Reference for DescribeSecurityGroups Operation Task DescribeSecurityGroupsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes the specified security groups or all of your security groups. ///

/// Container for the necessary parameters to execute the DescribeSecurityGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSecurityGroups service method, as returned by EC2. /// REST API Reference for DescribeSecurityGroups Operation Task DescribeSecurityGroupsAsync(DescribeSecurityGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSnapshotAttribute ///

/// Describes the specified attribute of the specified snapshot. You can specify only /// one attribute at a time. /// /// /// /// For more information about EBS snapshots, see Amazon /// EBS snapshots in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeSnapshotAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSnapshotAttribute service method, as returned by EC2. /// REST API Reference for DescribeSnapshotAttribute Operation Task DescribeSnapshotAttributeAsync(DescribeSnapshotAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSnapshots ///

/// Describes the specified EBS snapshots available to you or all of the EBS snapshots /// available to you. /// /// /// /// The snapshots available to you include public snapshots, private snapshots that you /// own, and private snapshots owned by other Amazon Web Services accounts for which you /// have explicit create volume permissions. /// /// /// /// The create volume permissions fall into the following categories: /// ///

/// /// public: The owner of the snapshot granted create volume permissions for the /// snapshot to the all group. All Amazon Web Services accounts have create /// volume permissions for these snapshots. /// ///
/// /// explicit: The owner of the snapshot granted create volume permissions to a /// specific Amazon Web Services account. /// ///
/// /// implicit: An Amazon Web Services account has implicit create volume permissions /// for all snapshots it owns. /// ///

/// /// The list of snapshots returned can be filtered by specifying snapshot IDs, snapshot /// owners, or Amazon Web Services accounts with create volume permissions. If no options /// are specified, Amazon EC2 returns all snapshots for which you have create volume permissions. /// /// /// /// If you specify one or more snapshot IDs, only snapshots that have the specified IDs /// are returned. If you specify an invalid snapshot ID, an error is returned. If you /// specify a snapshot ID for which you do not have access, it is not included in the /// returned results. /// /// /// /// If you specify one or more snapshot owners using the OwnerIds option, /// only snapshots from the specified owners and for which you have access are returned. /// The results can include the Amazon Web Services account IDs of the specified owners, /// amazon for snapshots owned by Amazon, or self for snapshots /// that you own. /// /// /// /// If you specify a list of restorable users, only snapshots with create snapshot permissions /// for those users are returned. You can specify Amazon Web Services account IDs (if /// you own the snapshots), self for snapshots for which you own or have /// explicit permissions, or all for public snapshots. /// /// /// /// If you are describing a long list of snapshots, we recommend that you paginate the /// output to make the list more manageable. For more information, see Pagination. /// /// /// /// To get the state of fast snapshot restores for a snapshot, use DescribeFastSnapshotRestores. /// /// /// /// For more information about EBS snapshots, see Amazon /// EBS snapshots in the Amazon Elastic Compute Cloud User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSnapshots service method, as returned by EC2. /// REST API Reference for DescribeSnapshots Operation Task DescribeSnapshotsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// /// public: The owner of the snapshot granted create volume permissions for the /// snapshot to the all group. All Amazon Web Services accounts have create /// volume permissions for these snapshots. /// ///
/// /// explicit: The owner of the snapshot granted create volume permissions to a /// specific Amazon Web Services account. /// ///
/// /// implicit: An Amazon Web Services account has implicit create volume permissions /// for all snapshots it owns. /// ///

/// Container for the necessary parameters to execute the DescribeSnapshots service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSnapshots service method, as returned by EC2. /// REST API Reference for DescribeSnapshots Operation Task DescribeSnapshotsAsync(DescribeSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSnapshotTierStatus ///

/// Describes the storage tier status of one or more Amazon EBS snapshots. ///

/// Container for the necessary parameters to execute the DescribeSnapshotTierStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSnapshotTierStatus service method, as returned by EC2. /// REST API Reference for DescribeSnapshotTierStatus Operation Task DescribeSnapshotTierStatusAsync(DescribeSnapshotTierStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSpotDatafeedSubscription ///

/// Describes the data feed for Spot Instances. For more information, see Spot /// Instance data feed in the Amazon EC2 User Guide for Linux Instances. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSpotDatafeedSubscription service method, as returned by EC2. /// REST API Reference for DescribeSpotDatafeedSubscription Operation Task DescribeSpotDatafeedSubscriptionAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes the data feed for Spot Instances. For more information, see Spot /// Instance data feed in the Amazon EC2 User Guide for Linux Instances. ///

/// Container for the necessary parameters to execute the DescribeSpotDatafeedSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSpotDatafeedSubscription service method, as returned by EC2. /// REST API Reference for DescribeSpotDatafeedSubscription Operation Task DescribeSpotDatafeedSubscriptionAsync(DescribeSpotDatafeedSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSpotFleetInstances ///

/// Describes the running instances for the specified Spot Fleet. ///

/// Container for the necessary parameters to execute the DescribeSpotFleetInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSpotFleetInstances service method, as returned by EC2. /// REST API Reference for DescribeSpotFleetInstances Operation Task DescribeSpotFleetInstancesAsync(DescribeSpotFleetInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSpotFleetRequestHistory ///

/// Describes the events for the specified Spot Fleet request during the specified time. /// /// /// /// Spot Fleet events are delayed by up to 30 seconds before they can be described. This /// ensures that you can query by the last evaluated time and not miss a recorded event. /// Spot Fleet events are available for 48 hours. /// /// /// /// For more information, see Monitor /// fleet events using Amazon EventBridge in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeSpotFleetRequestHistory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSpotFleetRequestHistory service method, as returned by EC2. /// REST API Reference for DescribeSpotFleetRequestHistory Operation Task DescribeSpotFleetRequestHistoryAsync(DescribeSpotFleetRequestHistoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSpotFleetRequests ///

/// Describes your Spot Fleet requests. /// /// /// /// Spot Fleet requests are deleted 48 hours after they are canceled and their instances /// are terminated. /// ///

/// Container for the necessary parameters to execute the DescribeSpotFleetRequests service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSpotFleetRequests service method, as returned by EC2. /// REST API Reference for DescribeSpotFleetRequests Operation Task DescribeSpotFleetRequestsAsync(DescribeSpotFleetRequestsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSpotInstanceRequests ///

/// Describes the specified Spot Instance requests. /// /// /// /// You can use DescribeSpotInstanceRequests to find a running Spot Instance /// by examining the response. If the status of the Spot Instance is fulfilled, /// the instance ID appears in the response and contains the identifier of the instance. /// Alternatively, you can use DescribeInstances /// with a filter to look for instances where the instance lifecycle is spot. /// /// /// /// We recommend that you set MaxResults to a value between 5 and 1000 to /// limit the number of items returned. This paginates the output, which makes the list /// more manageable and returns the items faster. If the list of items exceeds your MaxResults /// value, then that number of items is returned along with a NextToken value /// that can be passed to a subsequent DescribeSpotInstanceRequests request /// to retrieve the remaining items. /// /// /// /// Spot Instance requests are deleted four hours after they are canceled and their instances /// are terminated. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSpotInstanceRequests service method, as returned by EC2. /// REST API Reference for DescribeSpotInstanceRequests Operation Task DescribeSpotInstanceRequestsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeSpotInstanceRequests service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSpotInstanceRequests service method, as returned by EC2. /// REST API Reference for DescribeSpotInstanceRequests Operation Task DescribeSpotInstanceRequestsAsync(DescribeSpotInstanceRequestsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSpotPriceHistory ///

/// Describes the Spot price history. For more information, see Spot /// Instance pricing history in the Amazon EC2 User Guide for Linux Instances. /// /// /// /// When you specify a start and end time, the operation returns the prices of the instance /// types within that time range. It also returns the last price change before the start /// time, which is the effective price as of the start time. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSpotPriceHistory service method, as returned by EC2. /// REST API Reference for DescribeSpotPriceHistory Operation Task DescribeSpotPriceHistoryAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeSpotPriceHistory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSpotPriceHistory service method, as returned by EC2. /// REST API Reference for DescribeSpotPriceHistory Operation Task DescribeSpotPriceHistoryAsync(DescribeSpotPriceHistoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeStaleSecurityGroups ///

/// Describes the stale security group rules for security groups in a specified VPC. Rules /// are stale when they reference a deleted security group in the same VPC or in a peer /// VPC, or if they reference a security group in a peer VPC for which the VPC peering /// connection has been deleted. ///

/// Container for the necessary parameters to execute the DescribeStaleSecurityGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeStaleSecurityGroups service method, as returned by EC2. /// REST API Reference for DescribeStaleSecurityGroups Operation Task DescribeStaleSecurityGroupsAsync(DescribeStaleSecurityGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeStoreImageTasks ///

/// Describes the progress of the AMI store tasks. You can describe the store tasks for /// specified AMIs. If you don't specify the AMIs, you get a paginated list of store tasks /// from the last 31 days. /// /// /// /// For each AMI task, the response indicates if the task is InProgress, /// Completed, or Failed. For tasks InProgress, /// the response shows the estimated progress as a percentage. /// /// /// /// Tasks are listed in reverse chronological order. Currently, only tasks from the past /// 31 days can be viewed. /// /// /// /// To use this API, you must have the required permissions. For more information, see /// Permissions /// for storing and restoring AMIs using Amazon S3 in the Amazon EC2 User Guide. /// /// /// /// For more information, see Store /// and restore an AMI using Amazon S3 in the Amazon EC2 User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeStoreImageTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeStoreImageTasks service method, as returned by EC2. /// REST API Reference for DescribeStoreImageTasks Operation Task DescribeStoreImageTasksAsync(DescribeStoreImageTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeSubnets ///

/// Describes one or more of your subnets. /// /// /// /// For more information, see Subnets /// in the Amazon VPC User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSubnets service method, as returned by EC2. /// REST API Reference for DescribeSubnets Operation Task DescribeSubnetsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes one or more of your subnets. /// /// /// /// For more information, see Subnets /// in the Amazon VPC User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeSubnets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSubnets service method, as returned by EC2. /// REST API Reference for DescribeSubnets Operation Task DescribeSubnetsAsync(DescribeSubnetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTags ///

/// Describes the specified tags for your EC2 resources. /// /// /// /// For more information about tags, see Tag /// your Amazon EC2 resources in the Amazon Elastic Compute Cloud User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTags service method, as returned by EC2. /// REST API Reference for DescribeTags Operation Task DescribeTagsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeTags service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTags service method, as returned by EC2. /// REST API Reference for DescribeTags Operation Task DescribeTagsAsync(DescribeTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTrafficMirrorFilters ///

/// Describes one or more Traffic Mirror filters. ///

/// Container for the necessary parameters to execute the DescribeTrafficMirrorFilters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTrafficMirrorFilters service method, as returned by EC2. /// REST API Reference for DescribeTrafficMirrorFilters Operation Task DescribeTrafficMirrorFiltersAsync(DescribeTrafficMirrorFiltersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTrafficMirrorSessions ///

/// Describes one or more Traffic Mirror sessions. By default, all Traffic Mirror sessions /// are described. Alternatively, you can filter the results. ///

/// Container for the necessary parameters to execute the DescribeTrafficMirrorSessions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTrafficMirrorSessions service method, as returned by EC2. /// REST API Reference for DescribeTrafficMirrorSessions Operation Task DescribeTrafficMirrorSessionsAsync(DescribeTrafficMirrorSessionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTrafficMirrorTargets ///

/// Information about one or more Traffic Mirror targets. ///

/// Container for the necessary parameters to execute the DescribeTrafficMirrorTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTrafficMirrorTargets service method, as returned by EC2. /// REST API Reference for DescribeTrafficMirrorTargets Operation Task DescribeTrafficMirrorTargetsAsync(DescribeTrafficMirrorTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGatewayAttachments ///

/// Describes one or more attachments between resources and transit gateways. By default, /// all attachments are described. Alternatively, you can filter the results by attachment /// ID, attachment state, resource ID, or resource owner. ///

/// Container for the necessary parameters to execute the DescribeTransitGatewayAttachments service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGatewayAttachments service method, as returned by EC2. /// REST API Reference for DescribeTransitGatewayAttachments Operation Task DescribeTransitGatewayAttachmentsAsync(DescribeTransitGatewayAttachmentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGatewayConnectPeers ///

/// Describes one or more Connect peers. ///

/// Container for the necessary parameters to execute the DescribeTransitGatewayConnectPeers service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGatewayConnectPeers service method, as returned by EC2. /// REST API Reference for DescribeTransitGatewayConnectPeers Operation Task DescribeTransitGatewayConnectPeersAsync(DescribeTransitGatewayConnectPeersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGatewayConnects ///

/// Describes one or more Connect attachments. ///

/// Container for the necessary parameters to execute the DescribeTransitGatewayConnects service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGatewayConnects service method, as returned by EC2. /// REST API Reference for DescribeTransitGatewayConnects Operation Task DescribeTransitGatewayConnectsAsync(DescribeTransitGatewayConnectsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGatewayMulticastDomains ///

/// Describes one or more transit gateway multicast domains. ///

/// Container for the necessary parameters to execute the DescribeTransitGatewayMulticastDomains service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGatewayMulticastDomains service method, as returned by EC2. /// REST API Reference for DescribeTransitGatewayMulticastDomains Operation Task DescribeTransitGatewayMulticastDomainsAsync(DescribeTransitGatewayMulticastDomainsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGatewayPeeringAttachments ///

/// Describes your transit gateway peering attachments. ///

/// Container for the necessary parameters to execute the DescribeTransitGatewayPeeringAttachments service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGatewayPeeringAttachments service method, as returned by EC2. /// REST API Reference for DescribeTransitGatewayPeeringAttachments Operation Task DescribeTransitGatewayPeeringAttachmentsAsync(DescribeTransitGatewayPeeringAttachmentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGatewayPolicyTables ///

/// Describes one or more transit gateway route policy tables. ///

/// Container for the necessary parameters to execute the DescribeTransitGatewayPolicyTables service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGatewayPolicyTables service method, as returned by EC2. /// REST API Reference for DescribeTransitGatewayPolicyTables Operation Task DescribeTransitGatewayPolicyTablesAsync(DescribeTransitGatewayPolicyTablesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGatewayRouteTableAnnouncements ///

/// Describes one or more transit gateway route table advertisements. ///

/// Container for the necessary parameters to execute the DescribeTransitGatewayRouteTableAnnouncements service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGatewayRouteTableAnnouncements service method, as returned by EC2. /// REST API Reference for DescribeTransitGatewayRouteTableAnnouncements Operation Task DescribeTransitGatewayRouteTableAnnouncementsAsync(DescribeTransitGatewayRouteTableAnnouncementsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGatewayRouteTables ///

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

/// Container for the necessary parameters to execute the DescribeTransitGatewayRouteTables service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGatewayRouteTables service method, as returned by EC2. /// REST API Reference for DescribeTransitGatewayRouteTables Operation Task DescribeTransitGatewayRouteTablesAsync(DescribeTransitGatewayRouteTablesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGateways ///

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

/// Container for the necessary parameters to execute the DescribeTransitGateways service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGateways service method, as returned by EC2. /// REST API Reference for DescribeTransitGateways Operation Task DescribeTransitGatewaysAsync(DescribeTransitGatewaysRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTransitGatewayVpcAttachments ///

/// Describes one or more VPC attachments. By default, all VPC attachments are described. /// Alternatively, you can filter the results. ///

/// Container for the necessary parameters to execute the DescribeTransitGatewayVpcAttachments service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTransitGatewayVpcAttachments service method, as returned by EC2. /// REST API Reference for DescribeTransitGatewayVpcAttachments Operation Task DescribeTransitGatewayVpcAttachmentsAsync(DescribeTransitGatewayVpcAttachmentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeTrunkInterfaceAssociations ///

/// /// /// This API action is currently in limited preview only. If you are interested /// in using this feature, contact your account manager. /// /// /// /// Describes one or more network interface trunk associations. /// ///

/// Container for the necessary parameters to execute the DescribeTrunkInterfaceAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeTrunkInterfaceAssociations service method, as returned by EC2. /// REST API Reference for DescribeTrunkInterfaceAssociations Operation Task DescribeTrunkInterfaceAssociationsAsync(DescribeTrunkInterfaceAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVerifiedAccessEndpoints ///

/// Describes the specified Amazon Web Services Verified Access endpoints. ///

/// Container for the necessary parameters to execute the DescribeVerifiedAccessEndpoints service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVerifiedAccessEndpoints service method, as returned by EC2. /// REST API Reference for DescribeVerifiedAccessEndpoints Operation Task DescribeVerifiedAccessEndpointsAsync(DescribeVerifiedAccessEndpointsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVerifiedAccessGroups ///

/// Describes the specified Verified Access groups. ///

/// Container for the necessary parameters to execute the DescribeVerifiedAccessGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVerifiedAccessGroups service method, as returned by EC2. /// REST API Reference for DescribeVerifiedAccessGroups Operation Task DescribeVerifiedAccessGroupsAsync(DescribeVerifiedAccessGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVerifiedAccessInstanceLoggingConfigurations ///

/// Describes the specified Amazon Web Services Verified Access instances. ///

/// Container for the necessary parameters to execute the DescribeVerifiedAccessInstanceLoggingConfigurations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVerifiedAccessInstanceLoggingConfigurations service method, as returned by EC2. /// REST API Reference for DescribeVerifiedAccessInstanceLoggingConfigurations Operation Task DescribeVerifiedAccessInstanceLoggingConfigurationsAsync(DescribeVerifiedAccessInstanceLoggingConfigurationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVerifiedAccessInstances ///

/// Describes the specified Amazon Web Services Verified Access instances. ///

/// Container for the necessary parameters to execute the DescribeVerifiedAccessInstances service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVerifiedAccessInstances service method, as returned by EC2. /// REST API Reference for DescribeVerifiedAccessInstances Operation Task DescribeVerifiedAccessInstancesAsync(DescribeVerifiedAccessInstancesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVerifiedAccessTrustProviders ///

/// Describes the specified Amazon Web Services Verified Access trust providers. ///

/// Container for the necessary parameters to execute the DescribeVerifiedAccessTrustProviders service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVerifiedAccessTrustProviders service method, as returned by EC2. /// REST API Reference for DescribeVerifiedAccessTrustProviders Operation Task DescribeVerifiedAccessTrustProvidersAsync(DescribeVerifiedAccessTrustProvidersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVolumeAttribute ///

/// Describes the specified attribute of the specified volume. You can specify only one /// attribute at a time. /// /// /// /// For more information about EBS volumes, see Amazon /// EBS volumes in the Amazon Elastic Compute Cloud User Guide. /// ///

/// Container for the necessary parameters to execute the DescribeVolumeAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVolumeAttribute service method, as returned by EC2. /// REST API Reference for DescribeVolumeAttribute Operation Task DescribeVolumeAttributeAsync(DescribeVolumeAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVolumes ///

/// Describes the specified EBS volumes or all of your EBS volumes. /// /// /// /// If you are describing a long list of volumes, we recommend that you paginate the output /// to make the list more manageable. For more information, see Pagination. /// /// /// /// For more information about EBS volumes, see Amazon /// EBS volumes in the Amazon Elastic Compute Cloud User Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVolumes service method, as returned by EC2. /// REST API Reference for DescribeVolumes Operation Task DescribeVolumesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeVolumes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVolumes service method, as returned by EC2. /// REST API Reference for DescribeVolumes Operation Task DescribeVolumesAsync(DescribeVolumesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVolumesModifications ///

/// Describes the most recent volume modification request for the specified EBS volumes. /// /// /// /// If a volume has never been modified, some information in the output will be null. /// If a volume has been modified more than once, the output includes only the most recent /// modification request. /// /// /// /// You can also use CloudWatch Events to check the status of a modification to an EBS /// volume. For information about CloudWatch Events, see the Amazon /// CloudWatch Events User Guide. For more information, see Monitor /// the progress of volume modifications in the Amazon Elastic Compute Cloud User /// Guide. /// ///

/// Container for the necessary parameters to execute the DescribeVolumesModifications service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVolumesModifications service method, as returned by EC2. /// REST API Reference for DescribeVolumesModifications Operation Task DescribeVolumesModificationsAsync(DescribeVolumesModificationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVolumeStatus ///

/// Describes the status of the specified volumes. Volume status provides the result of /// the checks performed on your volumes to determine events that can impair the performance /// of your volumes. The performance of a volume can be affected if an issue occurs on /// the volume's underlying host. If the volume's underlying host experiences a power /// outage or system issue, after the system is restored, there could be data inconsistencies /// on the volume. Volume events notify you if this occurs. Volume actions notify you /// if any action needs to be taken in response to the event. /// /// /// /// The DescribeVolumeStatus operation provides the following information /// about the specified volumes: /// /// /// /// Status: Reflects the current status of the volume. The possible values are /// ok, impaired , warning, or insufficient-data. /// If all checks pass, the overall status of the volume is ok. If the check /// fails, the overall status is impaired. If the status is insufficient-data, /// then the checks might still be taking place on your volume at the time. We recommend /// that you retry the request. For more information about volume status, see Monitor /// the status of your volumes in the Amazon Elastic Compute Cloud User Guide. /// /// /// /// Events: Reflect the cause of a volume status and might require you to take /// action. For example, if your volume returns an impaired status, then /// the volume event might be potential-data-inconsistency. This means that /// your volume has been affected by an issue with the underlying host, has all I/O operations /// disabled, and might have inconsistent data. /// /// /// /// Actions: Reflect the actions you might have to take in response to an event. /// For example, if the status of the volume is impaired and the volume event /// shows potential-data-inconsistency, then the action shows enable-volume-io. /// This means that you may want to enable the I/O operations for the volume by calling /// the EnableVolumeIO action and then check the volume for data consistency. /// /// /// /// Volume status is based on the volume status checks, and does not reflect the volume /// state. Therefore, volume status does not indicate volumes in the error /// state (for example, when a volume is incapable of accepting I/O.) /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVolumeStatus service method, as returned by EC2. /// REST API Reference for DescribeVolumeStatus Operation Task DescribeVolumeStatusAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeVolumeStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVolumeStatus service method, as returned by EC2. /// REST API Reference for DescribeVolumeStatus Operation Task DescribeVolumeStatusAsync(DescribeVolumeStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcAttribute ///

/// Describes the specified attribute of the specified VPC. You can specify only one attribute /// at a time. ///

/// Container for the necessary parameters to execute the DescribeVpcAttribute service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcAttribute service method, as returned by EC2. /// REST API Reference for DescribeVpcAttribute Operation Task DescribeVpcAttributeAsync(DescribeVpcAttributeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcClassicLink ///

/// /// /// This action is deprecated. /// /// /// /// Describes the ClassicLink status of the specified VPCs. /// ///

/// Container for the necessary parameters to execute the DescribeVpcClassicLink service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcClassicLink service method, as returned by EC2. /// REST API Reference for DescribeVpcClassicLink Operation Task DescribeVpcClassicLinkAsync(DescribeVpcClassicLinkRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcClassicLinkDnsSupport ///

/// /// /// This action is deprecated. /// /// /// /// Describes the ClassicLink DNS support status of one or more VPCs. If enabled, the /// DNS hostname of a linked EC2-Classic instance resolves to its private IP address when /// addressed from an instance in the VPC to which it's linked. Similarly, the DNS hostname /// of an instance in a VPC resolves to its private IP address when addressed from a linked /// EC2-Classic instance. /// ///

/// Container for the necessary parameters to execute the DescribeVpcClassicLinkDnsSupport service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcClassicLinkDnsSupport service method, as returned by EC2. /// REST API Reference for DescribeVpcClassicLinkDnsSupport Operation Task DescribeVpcClassicLinkDnsSupportAsync(DescribeVpcClassicLinkDnsSupportRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcEndpointConnectionNotifications ///

/// Describes the connection notifications for VPC endpoints and VPC endpoint services. ///

/// Container for the necessary parameters to execute the DescribeVpcEndpointConnectionNotifications service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcEndpointConnectionNotifications service method, as returned by EC2. /// REST API Reference for DescribeVpcEndpointConnectionNotifications Operation Task DescribeVpcEndpointConnectionNotificationsAsync(DescribeVpcEndpointConnectionNotificationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcEndpointConnections ///

/// Describes the VPC endpoint connections to your VPC endpoint services, including any /// endpoints that are pending your acceptance. ///

/// Container for the necessary parameters to execute the DescribeVpcEndpointConnections service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcEndpointConnections service method, as returned by EC2. /// REST API Reference for DescribeVpcEndpointConnections Operation Task DescribeVpcEndpointConnectionsAsync(DescribeVpcEndpointConnectionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcEndpoints ///

/// Describes your VPC endpoints. ///

/// Container for the necessary parameters to execute the DescribeVpcEndpoints service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcEndpoints service method, as returned by EC2. /// REST API Reference for DescribeVpcEndpoints Operation Task DescribeVpcEndpointsAsync(DescribeVpcEndpointsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcEndpointServiceConfigurations ///

/// Describes the VPC endpoint service configurations in your account (your services). ///

/// Container for the necessary parameters to execute the DescribeVpcEndpointServiceConfigurations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcEndpointServiceConfigurations service method, as returned by EC2. /// REST API Reference for DescribeVpcEndpointServiceConfigurations Operation Task DescribeVpcEndpointServiceConfigurationsAsync(DescribeVpcEndpointServiceConfigurationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcEndpointServicePermissions ///

/// Describes the principals (service consumers) that are permitted to discover your VPC /// endpoint service. ///

/// Container for the necessary parameters to execute the DescribeVpcEndpointServicePermissions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcEndpointServicePermissions service method, as returned by EC2. /// REST API Reference for DescribeVpcEndpointServicePermissions Operation Task DescribeVpcEndpointServicePermissionsAsync(DescribeVpcEndpointServicePermissionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcEndpointServices ///

/// Describes available services to which you can create a VPC endpoint. /// /// /// /// When the service provider and the consumer have different accounts in multiple Availability /// Zones, and the consumer views the VPC endpoint service information, the response only /// includes the common Availability Zones. For example, when the service provider account /// uses us-east-1a and us-east-1c and the consumer uses us-east-1a /// and us-east-1b, the response includes the VPC endpoint services in the /// common Availability Zone, us-east-1a. /// ///

/// Container for the necessary parameters to execute the DescribeVpcEndpointServices service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcEndpointServices service method, as returned by EC2. /// REST API Reference for DescribeVpcEndpointServices Operation Task DescribeVpcEndpointServicesAsync(DescribeVpcEndpointServicesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcPeeringConnections ///

/// Describes one or more of your VPC peering connections. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcPeeringConnections service method, as returned by EC2. /// REST API Reference for DescribeVpcPeeringConnections Operation Task DescribeVpcPeeringConnectionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes one or more of your VPC peering connections. ///

/// Container for the necessary parameters to execute the DescribeVpcPeeringConnections service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcPeeringConnections service method, as returned by EC2. /// REST API Reference for DescribeVpcPeeringConnections Operation Task DescribeVpcPeeringConnectionsAsync(DescribeVpcPeeringConnectionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpcs ///

/// Describes one or more of your VPCs. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcs service method, as returned by EC2. /// REST API Reference for DescribeVpcs Operation Task DescribeVpcsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes one or more of your VPCs. ///

/// Container for the necessary parameters to execute the DescribeVpcs service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpcs service method, as returned by EC2. /// REST API Reference for DescribeVpcs Operation Task DescribeVpcsAsync(DescribeVpcsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpnConnections ///

/// Describes one or more of your VPN connections. /// /// /// /// For more information, see Amazon /// Web Services Site-to-Site VPN in the Amazon Web Services Site-to-Site VPN User /// Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpnConnections service method, as returned by EC2. /// REST API Reference for DescribeVpnConnections Operation Task DescribeVpnConnectionsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Container for the necessary parameters to execute the DescribeVpnConnections service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpnConnections service method, as returned by EC2. /// REST API Reference for DescribeVpnConnections Operation Task DescribeVpnConnectionsAsync(DescribeVpnConnectionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DescribeVpnGateways ///

/// Describes one or more of your virtual private gateways. /// /// /// /// For more information, see in the Amazon Web Services Site-to-Site VPN User /// Guide. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpnGateways service method, as returned by EC2. /// REST API Reference for DescribeVpnGateways Operation Task DescribeVpnGatewaysAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)); ///

/// Describes one or more of your virtual private gateways. /// /// /// ///

/// Container for the necessary parameters to execute the DescribeVpnGateways service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeVpnGateways service method, as returned by EC2. /// REST API Reference for DescribeVpnGateways Operation Task DescribeVpnGatewaysAsync(DescribeVpnGatewaysRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)); #endregion #region DetachClassicLinkVpc ///

/// Container for the necessary parameters to execute the DetachClassicLinkVpc service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// /// Task