/* * 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.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; using System.Collections.Generic; using System.Net; using Amazon.EC2.Model; using Amazon.EC2.Model.Internal.MarshallTransformations; using Amazon.EC2.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.EC2 { ///

/// Implementation 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 class AmazonEC2Client : AmazonServiceClient, IAmazonEC2 { private static IServiceMetadata serviceMetadata = new AmazonEC2Metadata(); private IEC2PaginatorFactory _paginators; ///

/// Paginators for the service ///

public IEC2PaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new EC2PaginatorFactory(this); } return this._paginators; } } #region Constructors ///

/// Constructs AmazonEC2Client with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonEC2Client() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonEC2Config()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonEC2Client(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonEC2Config{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonEC2Client Configuration Object public AmazonEC2Client(AmazonEC2Config config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonEC2Client with AWS Credentials ///

/// AWS Credentials public AmazonEC2Client(AWSCredentials credentials) : this(credentials, new AmazonEC2Config()) { } ///

/// Constructs AmazonEC2Client with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonEC2Client(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonEC2Config{RegionEndpoint = region}) { } ///

/// Constructs AmazonEC2Client with AWS Credentials and an /// AmazonEC2Client Configuration object. ///

/// AWS Credentials /// The AmazonEC2Client Configuration Object public AmazonEC2Client(AWSCredentials credentials, AmazonEC2Config clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonEC2Client with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonEC2Config()) { } ///

/// Constructs AmazonEC2Client with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonEC2Config() {RegionEndpoint=region}) { } ///

/// Constructs AmazonEC2Client with AWS Access Key ID, AWS Secret Key and an /// AmazonEC2Client Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonEC2Client Configuration Object public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, AmazonEC2Config clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonEC2Client with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonEC2Config()) { } ///

/// Constructs AmazonEC2Client with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonEC2Config{RegionEndpoint = region}) { } ///

/// Constructs AmazonEC2Client with AWS Access Key ID, AWS Secret Key and an /// AmazonEC2Client Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonEC2Client Configuration Object public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonEC2Config clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.AddHandlerBefore(new Amazon.EC2.Internal.AmazonEC2PreMarshallHandler(this.Credentials)); pipeline.AddHandlerAfter(new Amazon.EC2.Internal.AmazonEC2PostMarshallHandler()); pipeline.AddHandlerBefore(new Amazon.EC2.Internal.AmazonEC2ResponseHandler()); if(this.Config.RetryMode == RequestRetryMode.Legacy) { pipeline.ReplaceHandler(new Amazon.Runtime.Internal.RetryHandler(new Amazon.EC2.Internal.EC2RetryPolicy(this.Config))); } if(this.Config.RetryMode == RequestRetryMode.Standard) { pipeline.ReplaceHandler(new Amazon.Runtime.Internal.RetryHandler(new Amazon.EC2.Internal.EC2StandardRetryPolicy(this.Config))); } if(this.Config.RetryMode == RequestRetryMode.Adaptive) { pipeline.ReplaceHandler(new Amazon.Runtime.Internal.RetryHandler(new Amazon.EC2.Internal.EC2AdaptiveRetryPolicy(this.Config))); } pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonEC2EndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #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. /// /// The response from the AcceptAddressTransfer service method, as returned by EC2. /// REST API Reference for AcceptAddressTransfer Operation public virtual AcceptAddressTransferResponse AcceptAddressTransfer(AcceptAddressTransferRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptAddressTransferRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptAddressTransferResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AcceptAddressTransferAsync(AcceptAddressTransferRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptAddressTransferRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptAddressTransferResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AcceptReservedInstancesExchangeQuote service method, as returned by EC2. /// REST API Reference for AcceptReservedInstancesExchangeQuote Operation public virtual AcceptReservedInstancesExchangeQuoteResponse AcceptReservedInstancesExchangeQuote(AcceptReservedInstancesExchangeQuoteRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptReservedInstancesExchangeQuoteRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptReservedInstancesExchangeQuoteResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AcceptReservedInstancesExchangeQuoteAsync(AcceptReservedInstancesExchangeQuoteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptReservedInstancesExchangeQuoteRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptReservedInstancesExchangeQuoteResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AcceptTransitGatewayMulticastDomainAssociations service method, as returned by EC2. /// REST API Reference for AcceptTransitGatewayMulticastDomainAssociations Operation public virtual AcceptTransitGatewayMulticastDomainAssociationsResponse AcceptTransitGatewayMulticastDomainAssociations(AcceptTransitGatewayMulticastDomainAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AcceptTransitGatewayMulticastDomainAssociationsAsync(AcceptTransitGatewayMulticastDomainAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AcceptTransitGatewayPeeringAttachment service method, as returned by EC2. /// REST API Reference for AcceptTransitGatewayPeeringAttachment Operation public virtual AcceptTransitGatewayPeeringAttachmentResponse AcceptTransitGatewayPeeringAttachment(AcceptTransitGatewayPeeringAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptTransitGatewayPeeringAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AcceptTransitGatewayPeeringAttachmentAsync(AcceptTransitGatewayPeeringAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptTransitGatewayPeeringAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AcceptTransitGatewayVpcAttachment service method, as returned by EC2. /// REST API Reference for AcceptTransitGatewayVpcAttachment Operation public virtual AcceptTransitGatewayVpcAttachmentResponse AcceptTransitGatewayVpcAttachment(AcceptTransitGatewayVpcAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptTransitGatewayVpcAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptTransitGatewayVpcAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AcceptTransitGatewayVpcAttachmentAsync(AcceptTransitGatewayVpcAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptTransitGatewayVpcAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptTransitGatewayVpcAttachmentResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AcceptVpcEndpointConnections ///

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

/// Container for the necessary parameters to execute the AcceptVpcEndpointConnections service method. /// /// The response from the AcceptVpcEndpointConnections service method, as returned by EC2. /// REST API Reference for AcceptVpcEndpointConnections Operation public virtual AcceptVpcEndpointConnectionsResponse AcceptVpcEndpointConnections(AcceptVpcEndpointConnectionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptVpcEndpointConnectionsRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptVpcEndpointConnectionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AcceptVpcEndpointConnectionsAsync(AcceptVpcEndpointConnectionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptVpcEndpointConnectionsRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptVpcEndpointConnectionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AcceptVpcPeeringConnection service method, as returned by EC2. /// REST API Reference for AcceptVpcPeeringConnection Operation public virtual AcceptVpcPeeringConnectionResponse AcceptVpcPeeringConnection(AcceptVpcPeeringConnectionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptVpcPeeringConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptVpcPeeringConnectionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AcceptVpcPeeringConnectionAsync(AcceptVpcPeeringConnectionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptVpcPeeringConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptVpcPeeringConnectionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AdvertiseByoipCidr service method, as returned by EC2. /// REST API Reference for AdvertiseByoipCidr Operation public virtual AdvertiseByoipCidrResponse AdvertiseByoipCidr(AdvertiseByoipCidrRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AdvertiseByoipCidrRequestMarshaller.Instance; options.ResponseUnmarshaller = AdvertiseByoipCidrResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AdvertiseByoipCidrAsync(AdvertiseByoipCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AdvertiseByoipCidrRequestMarshaller.Instance; options.ResponseUnmarshaller = AdvertiseByoipCidrResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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). /// ///

/// /// The response from the AllocateAddress service method, as returned by EC2. /// REST API Reference for AllocateAddress Operation public virtual AllocateAddressResponse AllocateAddress() { return AllocateAddress(new AllocateAddressRequest()); } ///

/// Container for the necessary parameters to execute the AllocateAddress service method. /// /// The response from the AllocateAddress service method, as returned by EC2. /// REST API Reference for AllocateAddress Operation public virtual AllocateAddressResponse AllocateAddress(AllocateAddressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AllocateAddressRequestMarshaller.Instance; options.ResponseUnmarshaller = AllocateAddressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// 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 public virtual Task AllocateAddressAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return AllocateAddressAsync(new AllocateAddressRequest(), 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 public virtual Task AllocateAddressAsync(AllocateAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AllocateAddressRequestMarshaller.Instance; options.ResponseUnmarshaller = AllocateAddressResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AllocateHosts service method, as returned by EC2. /// REST API Reference for AllocateHosts Operation public virtual AllocateHostsResponse AllocateHosts(AllocateHostsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AllocateHostsRequestMarshaller.Instance; options.ResponseUnmarshaller = AllocateHostsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AllocateHostsAsync(AllocateHostsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AllocateHostsRequestMarshaller.Instance; options.ResponseUnmarshaller = AllocateHostsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AllocateIpamPoolCidr service method, as returned by EC2. /// REST API Reference for AllocateIpamPoolCidr Operation public virtual AllocateIpamPoolCidrResponse AllocateIpamPoolCidr(AllocateIpamPoolCidrRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AllocateIpamPoolCidrRequestMarshaller.Instance; options.ResponseUnmarshaller = AllocateIpamPoolCidrResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AllocateIpamPoolCidrAsync(AllocateIpamPoolCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AllocateIpamPoolCidrRequestMarshaller.Instance; options.ResponseUnmarshaller = AllocateIpamPoolCidrResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the ApplySecurityGroupsToClientVpnTargetNetwork service method, as returned by EC2. /// REST API Reference for ApplySecurityGroupsToClientVpnTargetNetwork Operation public virtual ApplySecurityGroupsToClientVpnTargetNetworkResponse ApplySecurityGroupsToClientVpnTargetNetwork(ApplySecurityGroupsToClientVpnTargetNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ApplySecurityGroupsToClientVpnTargetNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = ApplySecurityGroupsToClientVpnTargetNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task ApplySecurityGroupsToClientVpnTargetNetworkAsync(ApplySecurityGroupsToClientVpnTargetNetworkRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ApplySecurityGroupsToClientVpnTargetNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = ApplySecurityGroupsToClientVpnTargetNetworkResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssignIpv6Addresses service method, as returned by EC2. /// REST API Reference for AssignIpv6Addresses Operation public virtual AssignIpv6AddressesResponse AssignIpv6Addresses(AssignIpv6AddressesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssignIpv6AddressesRequestMarshaller.Instance; options.ResponseUnmarshaller = AssignIpv6AddressesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssignIpv6AddressesAsync(AssignIpv6AddressesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssignIpv6AddressesRequestMarshaller.Instance; options.ResponseUnmarshaller = AssignIpv6AddressesResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssignPrivateIpAddresses service method, as returned by EC2. /// REST API Reference for AssignPrivateIpAddresses Operation public virtual AssignPrivateIpAddressesResponse AssignPrivateIpAddresses(AssignPrivateIpAddressesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssignPrivateIpAddressesRequestMarshaller.Instance; options.ResponseUnmarshaller = AssignPrivateIpAddressesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssignPrivateIpAddressesAsync(AssignPrivateIpAddressesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssignPrivateIpAddressesRequestMarshaller.Instance; options.ResponseUnmarshaller = AssignPrivateIpAddressesResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssignPrivateNatGatewayAddress service method, as returned by EC2. /// REST API Reference for AssignPrivateNatGatewayAddress Operation public virtual AssignPrivateNatGatewayAddressResponse AssignPrivateNatGatewayAddress(AssignPrivateNatGatewayAddressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssignPrivateNatGatewayAddressRequestMarshaller.Instance; options.ResponseUnmarshaller = AssignPrivateNatGatewayAddressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssignPrivateNatGatewayAddressAsync(AssignPrivateNatGatewayAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssignPrivateNatGatewayAddressRequestMarshaller.Instance; options.ResponseUnmarshaller = AssignPrivateNatGatewayAddressResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateAddress service method, as returned by EC2. /// REST API Reference for AssociateAddress Operation public virtual AssociateAddressResponse AssociateAddress(AssociateAddressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateAddressRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateAddressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateAddressAsync(AssociateAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateAddressRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateAddressResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateClientVpnTargetNetwork service method, as returned by EC2. /// REST API Reference for AssociateClientVpnTargetNetwork Operation public virtual AssociateClientVpnTargetNetworkResponse AssociateClientVpnTargetNetwork(AssociateClientVpnTargetNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateClientVpnTargetNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateClientVpnTargetNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateClientVpnTargetNetworkAsync(AssociateClientVpnTargetNetworkRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateClientVpnTargetNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateClientVpnTargetNetworkResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateDhcpOptions service method, as returned by EC2. /// REST API Reference for AssociateDhcpOptions Operation public virtual AssociateDhcpOptionsResponse AssociateDhcpOptions(AssociateDhcpOptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateDhcpOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateDhcpOptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateDhcpOptionsAsync(AssociateDhcpOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateDhcpOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateDhcpOptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateEnclaveCertificateIamRole service method, as returned by EC2. /// REST API Reference for AssociateEnclaveCertificateIamRole Operation public virtual AssociateEnclaveCertificateIamRoleResponse AssociateEnclaveCertificateIamRole(AssociateEnclaveCertificateIamRoleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateEnclaveCertificateIamRoleRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateEnclaveCertificateIamRoleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateEnclaveCertificateIamRoleAsync(AssociateEnclaveCertificateIamRoleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateEnclaveCertificateIamRoleRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateEnclaveCertificateIamRoleResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateIamInstanceProfile service method, as returned by EC2. /// REST API Reference for AssociateIamInstanceProfile Operation public virtual AssociateIamInstanceProfileResponse AssociateIamInstanceProfile(AssociateIamInstanceProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateIamInstanceProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateIamInstanceProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateIamInstanceProfileAsync(AssociateIamInstanceProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateIamInstanceProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateIamInstanceProfileResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateInstanceEventWindow service method, as returned by EC2. /// REST API Reference for AssociateInstanceEventWindow Operation public virtual AssociateInstanceEventWindowResponse AssociateInstanceEventWindow(AssociateInstanceEventWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateInstanceEventWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateInstanceEventWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateInstanceEventWindowAsync(AssociateInstanceEventWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateInstanceEventWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateInstanceEventWindowResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateIpamResourceDiscovery service method, as returned by EC2. /// REST API Reference for AssociateIpamResourceDiscovery Operation public virtual AssociateIpamResourceDiscoveryResponse AssociateIpamResourceDiscovery(AssociateIpamResourceDiscoveryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateIpamResourceDiscoveryRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateIpamResourceDiscoveryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateIpamResourceDiscoveryAsync(AssociateIpamResourceDiscoveryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateIpamResourceDiscoveryRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateIpamResourceDiscoveryResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateNatGatewayAddress service method, as returned by EC2. /// REST API Reference for AssociateNatGatewayAddress Operation public virtual AssociateNatGatewayAddressResponse AssociateNatGatewayAddress(AssociateNatGatewayAddressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateNatGatewayAddressRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateNatGatewayAddressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateNatGatewayAddressAsync(AssociateNatGatewayAddressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateNatGatewayAddressRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateNatGatewayAddressResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateRouteTable service method, as returned by EC2. /// REST API Reference for AssociateRouteTable Operation public virtual AssociateRouteTableResponse AssociateRouteTable(AssociateRouteTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateRouteTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateRouteTableAsync(AssociateRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateRouteTableResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateSubnetCidrBlock service method, as returned by EC2. /// REST API Reference for AssociateSubnetCidrBlock Operation public virtual AssociateSubnetCidrBlockResponse AssociateSubnetCidrBlock(AssociateSubnetCidrBlockRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateSubnetCidrBlockRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateSubnetCidrBlockResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateSubnetCidrBlockAsync(AssociateSubnetCidrBlockRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateSubnetCidrBlockRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateSubnetCidrBlockResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateTransitGatewayMulticastDomain service method, as returned by EC2. /// REST API Reference for AssociateTransitGatewayMulticastDomain Operation public virtual AssociateTransitGatewayMulticastDomainResponse AssociateTransitGatewayMulticastDomain(AssociateTransitGatewayMulticastDomainRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTransitGatewayMulticastDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTransitGatewayMulticastDomainResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateTransitGatewayMulticastDomainAsync(AssociateTransitGatewayMulticastDomainRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTransitGatewayMulticastDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTransitGatewayMulticastDomainResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateTransitGatewayPolicyTable service method, as returned by EC2. /// REST API Reference for AssociateTransitGatewayPolicyTable Operation public virtual AssociateTransitGatewayPolicyTableResponse AssociateTransitGatewayPolicyTable(AssociateTransitGatewayPolicyTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTransitGatewayPolicyTableRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTransitGatewayPolicyTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateTransitGatewayPolicyTableAsync(AssociateTransitGatewayPolicyTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTransitGatewayPolicyTableRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTransitGatewayPolicyTableResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateTransitGatewayRouteTable service method, as returned by EC2. /// REST API Reference for AssociateTransitGatewayRouteTable Operation public virtual AssociateTransitGatewayRouteTableResponse AssociateTransitGatewayRouteTable(AssociateTransitGatewayRouteTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTransitGatewayRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTransitGatewayRouteTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateTransitGatewayRouteTableAsync(AssociateTransitGatewayRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTransitGatewayRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTransitGatewayRouteTableResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateTrunkInterface service method, as returned by EC2. /// REST API Reference for AssociateTrunkInterface Operation public virtual AssociateTrunkInterfaceResponse AssociateTrunkInterface(AssociateTrunkInterfaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTrunkInterfaceRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTrunkInterfaceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateTrunkInterfaceAsync(AssociateTrunkInterfaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTrunkInterfaceRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTrunkInterfaceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AssociateVpcCidrBlock service method, as returned by EC2. /// REST API Reference for AssociateVpcCidrBlock Operation public virtual AssociateVpcCidrBlockResponse AssociateVpcCidrBlock(AssociateVpcCidrBlockRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateVpcCidrBlockRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateVpcCidrBlockResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AssociateVpcCidrBlockAsync(AssociateVpcCidrBlockRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateVpcCidrBlockRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateVpcCidrBlockResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AttachClassicLinkVpc service method, as returned by EC2. /// REST API Reference for AttachClassicLinkVpc Operation public virtual AttachClassicLinkVpcResponse AttachClassicLinkVpc(AttachClassicLinkVpcRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachClassicLinkVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachClassicLinkVpcResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AttachClassicLinkVpcAsync(AttachClassicLinkVpcRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachClassicLinkVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachClassicLinkVpcResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AttachInternetGateway service method, as returned by EC2. /// REST API Reference for AttachInternetGateway Operation public virtual AttachInternetGatewayResponse AttachInternetGateway(AttachInternetGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachInternetGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachInternetGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AttachInternetGatewayAsync(AttachInternetGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachInternetGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachInternetGatewayResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AttachNetworkInterface ///

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

/// Container for the necessary parameters to execute the AttachNetworkInterface service method. /// /// The response from the AttachNetworkInterface service method, as returned by EC2. /// REST API Reference for AttachNetworkInterface Operation public virtual AttachNetworkInterfaceResponse AttachNetworkInterface(AttachNetworkInterfaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachNetworkInterfaceRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachNetworkInterfaceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AttachNetworkInterfaceAsync(AttachNetworkInterfaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachNetworkInterfaceRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachNetworkInterfaceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AttachVerifiedAccessTrustProvider service method, as returned by EC2. /// REST API Reference for AttachVerifiedAccessTrustProvider Operation public virtual AttachVerifiedAccessTrustProviderResponse AttachVerifiedAccessTrustProvider(AttachVerifiedAccessTrustProviderRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachVerifiedAccessTrustProviderRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachVerifiedAccessTrustProviderResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AttachVerifiedAccessTrustProviderAsync(AttachVerifiedAccessTrustProviderRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachVerifiedAccessTrustProviderRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachVerifiedAccessTrustProviderResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AttachVolume service method, as returned by EC2. /// REST API Reference for AttachVolume Operation public virtual AttachVolumeResponse AttachVolume(AttachVolumeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachVolumeRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachVolumeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// 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 public virtual Task AttachVolumeAsync(AttachVolumeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachVolumeRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachVolumeResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AttachVpnGateway service method, as returned by EC2. /// REST API Reference for AttachVpnGateway Operation public virtual AttachVpnGatewayResponse AttachVpnGateway(AttachVpnGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachVpnGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachVpnGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AttachVpnGatewayAsync(AttachVpnGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachVpnGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachVpnGatewayResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AuthorizeClientVpnIngress service method, as returned by EC2. /// REST API Reference for AuthorizeClientVpnIngress Operation public virtual AuthorizeClientVpnIngressResponse AuthorizeClientVpnIngress(AuthorizeClientVpnIngressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeClientVpnIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeClientVpnIngressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AuthorizeClientVpnIngressAsync(AuthorizeClientVpnIngressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeClientVpnIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeClientVpnIngressResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AuthorizeSecurityGroupEgress service method, as returned by EC2. /// REST API Reference for AuthorizeSecurityGroupEgress Operation public virtual AuthorizeSecurityGroupEgressResponse AuthorizeSecurityGroupEgress(AuthorizeSecurityGroupEgressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeSecurityGroupEgressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeSecurityGroupEgressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AuthorizeSecurityGroupEgressAsync(AuthorizeSecurityGroupEgressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeSecurityGroupEgressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeSecurityGroupEgressResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the AuthorizeSecurityGroupIngress service method, as returned by EC2. /// REST API Reference for AuthorizeSecurityGroupIngress Operation public virtual AuthorizeSecurityGroupIngressResponse AuthorizeSecurityGroupIngress(AuthorizeSecurityGroupIngressRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeSecurityGroupIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeSecurityGroupIngressResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task AuthorizeSecurityGroupIngressAsync(AuthorizeSecurityGroupIngressRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AuthorizeSecurityGroupIngressRequestMarshaller.Instance; options.ResponseUnmarshaller = AuthorizeSecurityGroupIngressResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the BundleInstance service method, as returned by EC2. /// REST API Reference for BundleInstance Operation public virtual BundleInstanceResponse BundleInstance(BundleInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = BundleInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = BundleInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task BundleInstanceAsync(BundleInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = BundleInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = BundleInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelBundleTask service method, as returned by EC2. /// REST API Reference for CancelBundleTask Operation public virtual CancelBundleTaskResponse CancelBundleTask(CancelBundleTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelBundleTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelBundleTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelBundleTaskAsync(CancelBundleTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelBundleTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelBundleTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelCapacityReservation service method, as returned by EC2. /// REST API Reference for CancelCapacityReservation Operation public virtual CancelCapacityReservationResponse CancelCapacityReservation(CancelCapacityReservationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCapacityReservationRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCapacityReservationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelCapacityReservationAsync(CancelCapacityReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCapacityReservationRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCapacityReservationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelCapacityReservationFleets service method, as returned by EC2. /// REST API Reference for CancelCapacityReservationFleets Operation public virtual CancelCapacityReservationFleetsResponse CancelCapacityReservationFleets(CancelCapacityReservationFleetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCapacityReservationFleetsRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCapacityReservationFleetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelCapacityReservationFleetsAsync(CancelCapacityReservationFleetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCapacityReservationFleetsRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCapacityReservationFleetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelConversionTask service method, as returned by EC2. /// REST API Reference for CancelConversionTask Operation public virtual CancelConversionTaskResponse CancelConversionTask(CancelConversionTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelConversionTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelConversionTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelConversionTaskAsync(CancelConversionTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelConversionTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelConversionTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelExportTask service method, as returned by EC2. /// REST API Reference for CancelExportTask Operation public virtual CancelExportTaskResponse CancelExportTask(CancelExportTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelExportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelExportTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelExportTaskAsync(CancelExportTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelExportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelExportTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelImageLaunchPermission service method, as returned by EC2. /// REST API Reference for CancelImageLaunchPermission Operation public virtual CancelImageLaunchPermissionResponse CancelImageLaunchPermission(CancelImageLaunchPermissionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelImageLaunchPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelImageLaunchPermissionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelImageLaunchPermissionAsync(CancelImageLaunchPermissionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelImageLaunchPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelImageLaunchPermissionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelImportTask service method, as returned by EC2. /// REST API Reference for CancelImportTask Operation public virtual CancelImportTaskResponse CancelImportTask(CancelImportTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelImportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelImportTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelImportTaskAsync(CancelImportTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelImportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelImportTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelReservedInstancesListing service method, as returned by EC2. /// REST API Reference for CancelReservedInstancesListing Operation public virtual CancelReservedInstancesListingResponse CancelReservedInstancesListing(CancelReservedInstancesListingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelReservedInstancesListingRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelReservedInstancesListingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelReservedInstancesListingAsync(CancelReservedInstancesListingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelReservedInstancesListingRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelReservedInstancesListingResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelSpotFleetRequests service method, as returned by EC2. /// REST API Reference for CancelSpotFleetRequests Operation public virtual CancelSpotFleetRequestsResponse CancelSpotFleetRequests(CancelSpotFleetRequestsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelSpotFleetRequestsRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelSpotFleetRequestsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelSpotFleetRequestsAsync(CancelSpotFleetRequestsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelSpotFleetRequestsRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelSpotFleetRequestsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CancelSpotInstanceRequests service method, as returned by EC2. /// REST API Reference for CancelSpotInstanceRequests Operation public virtual CancelSpotInstanceRequestsResponse CancelSpotInstanceRequests(CancelSpotInstanceRequestsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelSpotInstanceRequestsRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelSpotInstanceRequestsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CancelSpotInstanceRequestsAsync(CancelSpotInstanceRequestsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelSpotInstanceRequestsRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelSpotInstanceRequestsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the ConfirmProductInstance service method, as returned by EC2. /// REST API Reference for ConfirmProductInstance Operation public virtual ConfirmProductInstanceResponse ConfirmProductInstance(ConfirmProductInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ConfirmProductInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = ConfirmProductInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task ConfirmProductInstanceAsync(ConfirmProductInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ConfirmProductInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = ConfirmProductInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CopyFpgaImage service method, as returned by EC2. /// REST API Reference for CopyFpgaImage Operation public virtual CopyFpgaImageResponse CopyFpgaImage(CopyFpgaImageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopyFpgaImageRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyFpgaImageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CopyFpgaImageAsync(CopyFpgaImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CopyFpgaImageRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyFpgaImageResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CopyImage service method, as returned by EC2. /// REST API Reference for CopyImage Operation public virtual CopyImageResponse CopyImage(CopyImageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopyImageRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyImageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CopyImageAsync(CopyImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CopyImageRequestMarshaller.Instance; options.ResponseUnmarshaller = CopyImageResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CopySnapshot service method, as returned by EC2. /// REST API Reference for CopySnapshot Operation public virtual CopySnapshotResponse CopySnapshot(CopySnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CopySnapshotAsync(CopySnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateCapacityReservation service method, as returned by EC2. /// REST API Reference for CreateCapacityReservation Operation public virtual CreateCapacityReservationResponse CreateCapacityReservation(CreateCapacityReservationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCapacityReservationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCapacityReservationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateCapacityReservationAsync(CreateCapacityReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCapacityReservationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCapacityReservationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateCapacityReservationFleet service method, as returned by EC2. /// REST API Reference for CreateCapacityReservationFleet Operation public virtual CreateCapacityReservationFleetResponse CreateCapacityReservationFleet(CreateCapacityReservationFleetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCapacityReservationFleetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCapacityReservationFleetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateCapacityReservationFleetAsync(CreateCapacityReservationFleetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCapacityReservationFleetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCapacityReservationFleetResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateCarrierGateway service method, as returned by EC2. /// REST API Reference for CreateCarrierGateway Operation public virtual CreateCarrierGatewayResponse CreateCarrierGateway(CreateCarrierGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCarrierGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCarrierGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateCarrierGatewayAsync(CreateCarrierGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCarrierGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCarrierGatewayResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateClientVpnEndpoint service method, as returned by EC2. /// REST API Reference for CreateClientVpnEndpoint Operation public virtual CreateClientVpnEndpointResponse CreateClientVpnEndpoint(CreateClientVpnEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClientVpnEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClientVpnEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateClientVpnEndpointAsync(CreateClientVpnEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClientVpnEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClientVpnEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateClientVpnRoute service method, as returned by EC2. /// REST API Reference for CreateClientVpnRoute Operation public virtual CreateClientVpnRouteResponse CreateClientVpnRoute(CreateClientVpnRouteRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClientVpnRouteRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClientVpnRouteResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateClientVpnRouteAsync(CreateClientVpnRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateClientVpnRouteRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateClientVpnRouteResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateCoipCidr ///

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

/// Container for the necessary parameters to execute the CreateCoipCidr service method. /// /// The response from the CreateCoipCidr service method, as returned by EC2. /// REST API Reference for CreateCoipCidr Operation public virtual CreateCoipCidrResponse CreateCoipCidr(CreateCoipCidrRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCoipCidrRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCoipCidrResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateCoipCidrAsync(CreateCoipCidrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCoipCidrRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCoipCidrResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateCoipPool ///

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

/// Container for the necessary parameters to execute the CreateCoipPool service method. /// /// The response from the CreateCoipPool service method, as returned by EC2. /// REST API Reference for CreateCoipPool Operation public virtual CreateCoipPoolResponse CreateCoipPool(CreateCoipPoolRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCoipPoolRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCoipPoolResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateCoipPoolAsync(CreateCoipPoolRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCoipPoolRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCoipPoolResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateCustomerGateway service method, as returned by EC2. /// REST API Reference for CreateCustomerGateway Operation public virtual CreateCustomerGatewayResponse CreateCustomerGateway(CreateCustomerGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomerGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomerGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateCustomerGatewayAsync(CreateCustomerGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomerGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomerGatewayResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateDefaultSubnet service method, as returned by EC2. /// REST API Reference for CreateDefaultSubnet Operation public virtual CreateDefaultSubnetResponse CreateDefaultSubnet(CreateDefaultSubnetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDefaultSubnetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDefaultSubnetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateDefaultSubnetAsync(CreateDefaultSubnetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDefaultSubnetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDefaultSubnetResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateDefaultVpc service method, as returned by EC2. /// REST API Reference for CreateDefaultVpc Operation public virtual CreateDefaultVpcResponse CreateDefaultVpc(CreateDefaultVpcRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDefaultVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDefaultVpcResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateDefaultVpcAsync(CreateDefaultVpcRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDefaultVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDefaultVpcResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateDhcpOptions service method, as returned by EC2. /// REST API Reference for CreateDhcpOptions Operation public virtual CreateDhcpOptionsResponse CreateDhcpOptions(CreateDhcpOptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDhcpOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDhcpOptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// 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. /// ///

/// 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 public virtual Task CreateDhcpOptionsAsync(CreateDhcpOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDhcpOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDhcpOptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateEgressOnlyInternetGateway service method, as returned by EC2. /// REST API Reference for CreateEgressOnlyInternetGateway Operation public virtual CreateEgressOnlyInternetGatewayResponse CreateEgressOnlyInternetGateway(CreateEgressOnlyInternetGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEgressOnlyInternetGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEgressOnlyInternetGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateEgressOnlyInternetGatewayAsync(CreateEgressOnlyInternetGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEgressOnlyInternetGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEgressOnlyInternetGatewayResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateFleet service method, as returned by EC2. /// REST API Reference for CreateFleet Operation public virtual CreateFleetResponse CreateFleet(CreateFleetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFleetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFleetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateFleetAsync(CreateFleetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFleetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFleetResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateFlowLogs service method, as returned by EC2. /// REST API Reference for CreateFlowLogs Operation public virtual CreateFlowLogsResponse CreateFlowLogs(CreateFlowLogsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFlowLogsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFlowLogsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateFlowLogsAsync(CreateFlowLogsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFlowLogsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFlowLogsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateFpgaImage service method, as returned by EC2. /// REST API Reference for CreateFpgaImage Operation public virtual CreateFpgaImageResponse CreateFpgaImage(CreateFpgaImageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFpgaImageRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFpgaImageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateFpgaImageAsync(CreateFpgaImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFpgaImageRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFpgaImageResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateImage service method, as returned by EC2. /// REST API Reference for CreateImage Operation public virtual CreateImageResponse CreateImage(CreateImageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateImageRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateImageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateImageAsync(CreateImageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateImageRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateImageResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateInstanceConnectEndpoint service method, as returned by EC2. /// REST API Reference for CreateInstanceConnectEndpoint Operation public virtual CreateInstanceConnectEndpointResponse CreateInstanceConnectEndpoint(CreateInstanceConnectEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstanceConnectEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstanceConnectEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateInstanceConnectEndpointAsync(CreateInstanceConnectEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstanceConnectEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstanceConnectEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateInstanceEventWindow service method, as returned by EC2. /// REST API Reference for CreateInstanceEventWindow Operation public virtual CreateInstanceEventWindowResponse CreateInstanceEventWindow(CreateInstanceEventWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstanceEventWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstanceEventWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// 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 public virtual Task CreateInstanceEventWindowAsync(CreateInstanceEventWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstanceEventWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstanceEventWindowResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateInstanceExportTask service method, as returned by EC2. /// REST API Reference for CreateInstanceExportTask Operation public virtual CreateInstanceExportTaskResponse CreateInstanceExportTask(CreateInstanceExportTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstanceExportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstanceExportTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateInstanceExportTaskAsync(CreateInstanceExportTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInstanceExportTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInstanceExportTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// ///

/// /// The response from the CreateInternetGateway service method, as returned by EC2. /// REST API Reference for CreateInternetGateway Operation public virtual CreateInternetGatewayResponse CreateInternetGateway() { return CreateInternetGateway(new CreateInternetGatewayRequest()); } ///

/// Container for the necessary parameters to execute the CreateInternetGateway service method. /// /// The response from the CreateInternetGateway service method, as returned by EC2. /// REST API Reference for CreateInternetGateway Operation public virtual CreateInternetGatewayResponse CreateInternetGateway(CreateInternetGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInternetGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInternetGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// /// 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 public virtual Task CreateInternetGatewayAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return CreateInternetGatewayAsync(new CreateInternetGatewayRequest(), 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 public virtual Task CreateInternetGatewayAsync(CreateInternetGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateInternetGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateInternetGatewayResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateIpam service method, as returned by EC2. /// REST API Reference for CreateIpam Operation public virtual CreateIpamResponse CreateIpam(CreateIpamRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateIpamRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateIpamResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateIpamAsync(CreateIpamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateIpamRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateIpamResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateIpamPool service method, as returned by EC2. /// REST API Reference for CreateIpamPool Operation public virtual CreateIpamPoolResponse CreateIpamPool(CreateIpamPoolRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateIpamPoolRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateIpamPoolResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateIpamPoolAsync(CreateIpamPoolRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateIpamPoolRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateIpamPoolResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateIpamResourceDiscovery service method, as returned by EC2. /// REST API Reference for CreateIpamResourceDiscovery Operation public virtual CreateIpamResourceDiscoveryResponse CreateIpamResourceDiscovery(CreateIpamResourceDiscoveryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateIpamResourceDiscoveryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateIpamResourceDiscoveryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateIpamResourceDiscoveryAsync(CreateIpamResourceDiscoveryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateIpamResourceDiscoveryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateIpamResourceDiscoveryResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateIpamScope service method, as returned by EC2. /// REST API Reference for CreateIpamScope Operation public virtual CreateIpamScopeResponse CreateIpamScope(CreateIpamScopeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateIpamScopeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateIpamScopeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateIpamScopeAsync(CreateIpamScopeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateIpamScopeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateIpamScopeResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateKeyPair service method, as returned by EC2. /// REST API Reference for CreateKeyPair Operation public virtual CreateKeyPairResponse CreateKeyPair(CreateKeyPairRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKeyPairResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateKeyPairAsync(CreateKeyPairRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKeyPairRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKeyPairResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateLaunchTemplate service method, as returned by EC2. /// REST API Reference for CreateLaunchTemplate Operation public virtual CreateLaunchTemplateResponse CreateLaunchTemplate(CreateLaunchTemplateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLaunchTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLaunchTemplateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateLaunchTemplateAsync(CreateLaunchTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLaunchTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLaunchTemplateResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateLaunchTemplateVersion service method, as returned by EC2. /// REST API Reference for CreateLaunchTemplateVersion Operation public virtual CreateLaunchTemplateVersionResponse CreateLaunchTemplateVersion(CreateLaunchTemplateVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLaunchTemplateVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLaunchTemplateVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateLaunchTemplateVersionAsync(CreateLaunchTemplateVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLaunchTemplateVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLaunchTemplateVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateLocalGatewayRoute service method, as returned by EC2. /// REST API Reference for CreateLocalGatewayRoute Operation public virtual CreateLocalGatewayRouteResponse CreateLocalGatewayRoute(CreateLocalGatewayRouteRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLocalGatewayRouteRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLocalGatewayRouteResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateLocalGatewayRouteAsync(CreateLocalGatewayRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLocalGatewayRouteRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLocalGatewayRouteResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateLocalGatewayRouteTable ///

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

/// Container for the necessary parameters to execute the CreateLocalGatewayRouteTable service method. /// /// The response from the CreateLocalGatewayRouteTable service method, as returned by EC2. /// REST API Reference for CreateLocalGatewayRouteTable Operation public virtual CreateLocalGatewayRouteTableResponse CreateLocalGatewayRouteTable(CreateLocalGatewayRouteTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLocalGatewayRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLocalGatewayRouteTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateLocalGatewayRouteTableAsync(CreateLocalGatewayRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLocalGatewayRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLocalGatewayRouteTableResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation service method, as returned by EC2. /// REST API Reference for CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation Operation public virtual CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponse CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationAsync(CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateLocalGatewayRouteTableVpcAssociation service method, as returned by EC2. /// REST API Reference for CreateLocalGatewayRouteTableVpcAssociation Operation public virtual CreateLocalGatewayRouteTableVpcAssociationResponse CreateLocalGatewayRouteTableVpcAssociation(CreateLocalGatewayRouteTableVpcAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLocalGatewayRouteTableVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLocalGatewayRouteTableVpcAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateLocalGatewayRouteTableVpcAssociationAsync(CreateLocalGatewayRouteTableVpcAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLocalGatewayRouteTableVpcAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLocalGatewayRouteTableVpcAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateManagedPrefixList service method, as returned by EC2. /// REST API Reference for CreateManagedPrefixList Operation public virtual CreateManagedPrefixListResponse CreateManagedPrefixList(CreateManagedPrefixListRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateManagedPrefixListRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateManagedPrefixListResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateManagedPrefixListAsync(CreateManagedPrefixListRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateManagedPrefixListRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateManagedPrefixListResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateNatGateway service method, as returned by EC2. /// REST API Reference for CreateNatGateway Operation public virtual CreateNatGatewayResponse CreateNatGateway(CreateNatGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNatGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNatGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateNatGatewayAsync(CreateNatGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNatGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNatGatewayResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateNetworkAcl service method, as returned by EC2. /// REST API Reference for CreateNetworkAcl Operation public virtual CreateNetworkAclResponse CreateNetworkAcl(CreateNetworkAclRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkAclRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkAclResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateNetworkAclAsync(CreateNetworkAclRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkAclRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkAclResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateNetworkAclEntry service method, as returned by EC2. /// REST API Reference for CreateNetworkAclEntry Operation public virtual CreateNetworkAclEntryResponse CreateNetworkAclEntry(CreateNetworkAclEntryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkAclEntryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkAclEntryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateNetworkAclEntryAsync(CreateNetworkAclEntryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkAclEntryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkAclEntryResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateNetworkInsightsAccessScope service method, as returned by EC2. /// REST API Reference for CreateNetworkInsightsAccessScope Operation public virtual CreateNetworkInsightsAccessScopeResponse CreateNetworkInsightsAccessScope(CreateNetworkInsightsAccessScopeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkInsightsAccessScopeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkInsightsAccessScopeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateNetworkInsightsAccessScopeAsync(CreateNetworkInsightsAccessScopeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkInsightsAccessScopeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkInsightsAccessScopeResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateNetworkInsightsPath service method, as returned by EC2. /// REST API Reference for CreateNetworkInsightsPath Operation public virtual CreateNetworkInsightsPathResponse CreateNetworkInsightsPath(CreateNetworkInsightsPathRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkInsightsPathRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkInsightsPathResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateNetworkInsightsPathAsync(CreateNetworkInsightsPathRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkInsightsPathRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkInsightsPathResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateNetworkInterface service method, as returned by EC2. /// REST API Reference for CreateNetworkInterface Operation public virtual CreateNetworkInterfaceResponse CreateNetworkInterface(CreateNetworkInterfaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkInterfaceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkInterfaceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateNetworkInterfaceAsync(CreateNetworkInterfaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkInterfaceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkInterfaceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateNetworkInterfacePermission service method, as returned by EC2. /// REST API Reference for CreateNetworkInterfacePermission Operation public virtual CreateNetworkInterfacePermissionResponse CreateNetworkInterfacePermission(CreateNetworkInterfacePermissionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkInterfacePermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkInterfacePermissionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateNetworkInterfacePermissionAsync(CreateNetworkInterfacePermissionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNetworkInterfacePermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNetworkInterfacePermissionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreatePlacementGroup service method, as returned by EC2. /// REST API Reference for CreatePlacementGroup Operation public virtual CreatePlacementGroupResponse CreatePlacementGroup(CreatePlacementGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePlacementGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePlacementGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreatePlacementGroupAsync(CreatePlacementGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePlacementGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePlacementGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreatePublicIpv4Pool service method, as returned by EC2. /// REST API Reference for CreatePublicIpv4Pool Operation public virtual CreatePublicIpv4PoolResponse CreatePublicIpv4Pool(CreatePublicIpv4PoolRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePublicIpv4PoolRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePublicIpv4PoolResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreatePublicIpv4PoolAsync(CreatePublicIpv4PoolRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePublicIpv4PoolRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePublicIpv4PoolResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateReplaceRootVolumeTask service method, as returned by EC2. /// REST API Reference for CreateReplaceRootVolumeTask Operation public virtual CreateReplaceRootVolumeTaskResponse CreateReplaceRootVolumeTask(CreateReplaceRootVolumeTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateReplaceRootVolumeTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateReplaceRootVolumeTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateReplaceRootVolumeTaskAsync(CreateReplaceRootVolumeTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateReplaceRootVolumeTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateReplaceRootVolumeTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateReservedInstancesListing service method, as returned by EC2. /// REST API Reference for CreateReservedInstancesListing Operation public virtual CreateReservedInstancesListingResponse CreateReservedInstancesListing(CreateReservedInstancesListingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateReservedInstancesListingRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateReservedInstancesListingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateReservedInstancesListingAsync(CreateReservedInstancesListingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateReservedInstancesListingRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateReservedInstancesListingResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateRestoreImageTask service method, as returned by EC2. /// REST API Reference for CreateRestoreImageTask Operation public virtual CreateRestoreImageTaskResponse CreateRestoreImageTask(CreateRestoreImageTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRestoreImageTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRestoreImageTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateRestoreImageTaskAsync(CreateRestoreImageTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRestoreImageTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRestoreImageTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateRoute service method, as returned by EC2. /// REST API Reference for CreateRoute Operation public virtual CreateRouteResponse CreateRoute(CreateRouteRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRouteRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRouteResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// 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 public virtual Task CreateRouteAsync(CreateRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRouteRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRouteResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateRouteTable service method, as returned by EC2. /// REST API Reference for CreateRouteTable Operation public virtual CreateRouteTableResponse CreateRouteTable(CreateRouteTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRouteTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateRouteTableAsync(CreateRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRouteTableResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateSecurityGroup service method, as returned by EC2. /// REST API Reference for CreateSecurityGroup Operation public virtual CreateSecurityGroupResponse CreateSecurityGroup(CreateSecurityGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSecurityGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateSecurityGroupAsync(CreateSecurityGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSecurityGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSecurityGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateSnapshot service method, as returned by EC2. /// REST API Reference for CreateSnapshot Operation public virtual CreateSnapshotResponse CreateSnapshot(CreateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateSnapshotAsync(CreateSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateSnapshots service method, as returned by EC2. /// REST API Reference for CreateSnapshots Operation public virtual CreateSnapshotsResponse CreateSnapshots(CreateSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateSnapshotsAsync(CreateSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateSpotDatafeedSubscription service method, as returned by EC2. /// REST API Reference for CreateSpotDatafeedSubscription Operation public virtual CreateSpotDatafeedSubscriptionResponse CreateSpotDatafeedSubscription(CreateSpotDatafeedSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSpotDatafeedSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSpotDatafeedSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateSpotDatafeedSubscriptionAsync(CreateSpotDatafeedSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSpotDatafeedSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSpotDatafeedSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateStoreImageTask service method, as returned by EC2. /// REST API Reference for CreateStoreImageTask Operation public virtual CreateStoreImageTaskResponse CreateStoreImageTask(CreateStoreImageTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateStoreImageTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateStoreImageTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateStoreImageTaskAsync(CreateStoreImageTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateStoreImageTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateStoreImageTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateSubnet service method, as returned by EC2. /// REST API Reference for CreateSubnet Operation public virtual CreateSubnetResponse CreateSubnet(CreateSubnetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubnetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubnetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateSubnetAsync(CreateSubnetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubnetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubnetResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateSubnetCidrReservation service method, as returned by EC2. /// REST API Reference for CreateSubnetCidrReservation Operation public virtual CreateSubnetCidrReservationResponse CreateSubnetCidrReservation(CreateSubnetCidrReservationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubnetCidrReservationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubnetCidrReservationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateSubnetCidrReservationAsync(CreateSubnetCidrReservationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSubnetCidrReservationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSubnetCidrReservationResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTags service method, as returned by EC2. /// REST API Reference for CreateTags Operation public virtual CreateTagsResponse CreateTags(CreateTagsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTagsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTagsAsync(CreateTagsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTagsRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTagsResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTrafficMirrorFilter service method, as returned by EC2. /// REST API Reference for CreateTrafficMirrorFilter Operation public virtual CreateTrafficMirrorFilterResponse CreateTrafficMirrorFilter(CreateTrafficMirrorFilterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrafficMirrorFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrafficMirrorFilterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTrafficMirrorFilterAsync(CreateTrafficMirrorFilterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrafficMirrorFilterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrafficMirrorFilterResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTrafficMirrorFilterRule service method, as returned by EC2. /// REST API Reference for CreateTrafficMirrorFilterRule Operation public virtual CreateTrafficMirrorFilterRuleResponse CreateTrafficMirrorFilterRule(CreateTrafficMirrorFilterRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrafficMirrorFilterRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrafficMirrorFilterRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTrafficMirrorFilterRuleAsync(CreateTrafficMirrorFilterRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrafficMirrorFilterRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrafficMirrorFilterRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTrafficMirrorSession service method, as returned by EC2. /// REST API Reference for CreateTrafficMirrorSession Operation public virtual CreateTrafficMirrorSessionResponse CreateTrafficMirrorSession(CreateTrafficMirrorSessionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrafficMirrorSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrafficMirrorSessionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTrafficMirrorSessionAsync(CreateTrafficMirrorSessionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrafficMirrorSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrafficMirrorSessionResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTrafficMirrorTarget service method, as returned by EC2. /// REST API Reference for CreateTrafficMirrorTarget Operation public virtual CreateTrafficMirrorTargetResponse CreateTrafficMirrorTarget(CreateTrafficMirrorTargetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrafficMirrorTargetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrafficMirrorTargetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTrafficMirrorTargetAsync(CreateTrafficMirrorTargetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrafficMirrorTargetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrafficMirrorTargetResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTransitGateway service method, as returned by EC2. /// REST API Reference for CreateTransitGateway Operation public virtual CreateTransitGatewayResponse CreateTransitGateway(CreateTransitGatewayRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayAsync(CreateTransitGatewayRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTransitGatewayConnect service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayConnect Operation public virtual CreateTransitGatewayConnectResponse CreateTransitGatewayConnect(CreateTransitGatewayConnectRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayConnectRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayConnectResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayConnectAsync(CreateTransitGatewayConnectRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayConnectRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayConnectResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTransitGatewayConnectPeer service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayConnectPeer Operation public virtual CreateTransitGatewayConnectPeerResponse CreateTransitGatewayConnectPeer(CreateTransitGatewayConnectPeerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayConnectPeerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayConnectPeerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayConnectPeerAsync(CreateTransitGatewayConnectPeerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayConnectPeerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayConnectPeerResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTransitGatewayMulticastDomain service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayMulticastDomain Operation public virtual CreateTransitGatewayMulticastDomainResponse CreateTransitGatewayMulticastDomain(CreateTransitGatewayMulticastDomainRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayMulticastDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayMulticastDomainResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayMulticastDomainAsync(CreateTransitGatewayMulticastDomainRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayMulticastDomainRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayMulticastDomainResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTransitGatewayPeeringAttachment service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayPeeringAttachment Operation public virtual CreateTransitGatewayPeeringAttachmentResponse CreateTransitGatewayPeeringAttachment(CreateTransitGatewayPeeringAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayPeeringAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayPeeringAttachmentAsync(CreateTransitGatewayPeeringAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayPeeringAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateTransitGatewayPolicyTable ///

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

/// Container for the necessary parameters to execute the CreateTransitGatewayPolicyTable service method. /// /// The response from the CreateTransitGatewayPolicyTable service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayPolicyTable Operation public virtual CreateTransitGatewayPolicyTableResponse CreateTransitGatewayPolicyTable(CreateTransitGatewayPolicyTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayPolicyTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayPolicyTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayPolicyTableAsync(CreateTransitGatewayPolicyTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayPolicyTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayPolicyTableResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTransitGatewayPrefixListReference service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayPrefixListReference Operation public virtual CreateTransitGatewayPrefixListReferenceResponse CreateTransitGatewayPrefixListReference(CreateTransitGatewayPrefixListReferenceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayPrefixListReferenceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayPrefixListReferenceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayPrefixListReferenceAsync(CreateTransitGatewayPrefixListReferenceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayPrefixListReferenceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayPrefixListReferenceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTransitGatewayRoute service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayRoute Operation public virtual CreateTransitGatewayRouteResponse CreateTransitGatewayRoute(CreateTransitGatewayRouteRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayRouteRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayRouteResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayRouteAsync(CreateTransitGatewayRouteRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayRouteRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayRouteResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateTransitGatewayRouteTable ///

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

/// Container for the necessary parameters to execute the CreateTransitGatewayRouteTable service method. /// /// The response from the CreateTransitGatewayRouteTable service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayRouteTable Operation public virtual CreateTransitGatewayRouteTableResponse CreateTransitGatewayRouteTable(CreateTransitGatewayRouteTableRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayRouteTableResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayRouteTableAsync(CreateTransitGatewayRouteTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayRouteTableRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayRouteTableResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateTransitGatewayRouteTableAnnouncement ///

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

/// Container for the necessary parameters to execute the CreateTransitGatewayRouteTableAnnouncement service method. /// /// The response from the CreateTransitGatewayRouteTableAnnouncement service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayRouteTableAnnouncement Operation public virtual CreateTransitGatewayRouteTableAnnouncementResponse CreateTransitGatewayRouteTableAnnouncement(CreateTransitGatewayRouteTableAnnouncementRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayRouteTableAnnouncementRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayRouteTableAnnouncementResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayRouteTableAnnouncementAsync(CreateTransitGatewayRouteTableAnnouncementRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayRouteTableAnnouncementRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayRouteTableAnnouncementResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateTransitGatewayVpcAttachment service method, as returned by EC2. /// REST API Reference for CreateTransitGatewayVpcAttachment Operation public virtual CreateTransitGatewayVpcAttachmentResponse CreateTransitGatewayVpcAttachment(CreateTransitGatewayVpcAttachmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayVpcAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayVpcAttachmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateTransitGatewayVpcAttachmentAsync(CreateTransitGatewayVpcAttachmentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTransitGatewayVpcAttachmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTransitGatewayVpcAttachmentResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateVerifiedAccessEndpoint service method, as returned by EC2. /// REST API Reference for CreateVerifiedAccessEndpoint Operation public virtual CreateVerifiedAccessEndpointResponse CreateVerifiedAccessEndpoint(CreateVerifiedAccessEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVerifiedAccessEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVerifiedAccessEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateVerifiedAccessEndpointAsync(CreateVerifiedAccessEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVerifiedAccessEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVerifiedAccessEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateVerifiedAccessGroup service method, as returned by EC2. /// REST API Reference for CreateVerifiedAccessGroup Operation public virtual CreateVerifiedAccessGroupResponse CreateVerifiedAccessGroup(CreateVerifiedAccessGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVerifiedAccessGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVerifiedAccessGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateVerifiedAccessGroupAsync(CreateVerifiedAccessGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVerifiedAccessGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVerifiedAccessGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateVerifiedAccessInstance service method, as returned by EC2. /// REST API Reference for CreateVerifiedAccessInstance Operation public virtual CreateVerifiedAccessInstanceResponse CreateVerifiedAccessInstance(CreateVerifiedAccessInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVerifiedAccessInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVerifiedAccessInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateVerifiedAccessInstanceAsync(CreateVerifiedAccessInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVerifiedAccessInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVerifiedAccessInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateVerifiedAccessTrustProvider service method, as returned by EC2. /// REST API Reference for CreateVerifiedAccessTrustProvider Operation public virtual CreateVerifiedAccessTrustProviderResponse CreateVerifiedAccessTrustProvider(CreateVerifiedAccessTrustProviderRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVerifiedAccessTrustProviderRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVerifiedAccessTrustProviderResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateVerifiedAccessTrustProviderAsync(CreateVerifiedAccessTrustProviderRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVerifiedAccessTrustProviderRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVerifiedAccessTrustProviderResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateVolume service method, as returned by EC2. /// REST API Reference for CreateVolume Operation public virtual CreateVolumeResponse CreateVolume(CreateVolumeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVolumeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVolumeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateVolumeAsync(CreateVolumeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVolumeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVolumeResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateVpc service method, as returned by EC2. /// REST API Reference for CreateVpc Operation public virtual CreateVpcResponse CreateVpc(CreateVpcRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVpcResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateVpcAsync(CreateVpcRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVpcRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVpcResponseUnmarshaller.Instance; return InvokeAsync(request, options, 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. /// /// The response from the CreateVpcEndpoint service method, as returned by EC2. /// REST API Reference for CreateVpcEndpoint Operation public virtual CreateVpcEndpointResponse CreateVpcEndpoint(CreateVpcEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVpcEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVpcEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 public virtual Task CreateVpcEndpointAsync(CreateVpcEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVpcEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVpcEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateVpcEndpointConnectionNotification ///

/// Container for the necessary parameters to execute the CreateVpcEndpointConnectionNotification service method. /// /// /// public virtual CreateVpcEndpointConnectionNotificationResponse CreateVpcEndpointConnectionNotification(CreateVpcEndpointConnectionNotificationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateVpcEndpointConnectionNotificationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateVpcEndpointConnectionNotificationResponseUnmarshaller.Instance; return Invoke